use super::*; use crate::lsp::types::{warning_to_code_actions, warning_to_diagnostic}; use crate::rule::LintWarning; use indoc::indoc; use tower_lsp::LspService; /// Spell a path the way the server spells it. /// /// A test that sets `workspace_roots` or seeds the workspace index by hand builds /// paths the server would otherwise build itself, so it has to build them the same /// way or it creates a state the server cannot reach. A bare `canonicalize` is not /// the same way: on Windows it returns the `\\?\` verbatim form, which no document /// URI carries, so an index keyed on it can never be looked up by an open document /// and every cross-file test would pass on Unix while going silently dead there. trait ResolveLikeServer { fn resolve_like_server(&self) -> std::path::PathBuf; } impl ResolveLikeServer for std::path::Path { fn resolve_like_server(&self) -> std::path::PathBuf { crate::lsp::resolve_workspace_root(self) } } fn create_test_server() -> RumdlLanguageServer { let (service, _socket) = LspService::new(|client| RumdlLanguageServer::new(client, None)); service.inner().clone() } #[tokio::test] async fn md096_quick_fix_and_fix_all_preserve_rows_with_overlapping_table_formatting() { let server = create_test_server(); let uri = Url::parse("untitled:table-sort.md").unwrap(); let mut config = crate::config::Config::default(); config.global.enable = vec!["MD060".into(), "MD096".into()]; for (rule, key, value) in [("MD096", "column", "Name"), ("MD060", "style", "aligned")] { config .rules .entry(rule.into()) .or_default() .values .insert(key.into(), toml::Value::String(value.into())); } *server.rumdl_config.write().await = config; let input = "\u{feff}|Name|Value|\n|---|---|\n|Zulu|2|\n|Alpha|1|\n"; let range = Range::new(Position::new(0, 0), Position::new(4, 0)); let actions = server.get_code_actions(&uri, input, range).await.unwrap(); let quick_fix = actions .iter() .find(|action| { action.kind.as_ref() == Some(&CodeActionKind::QUICKFIX) && action.diagnostics.as_ref().is_some_and(|diagnostics| { diagnostics .iter() .any(|diagnostic| diagnostic.code == Some(NumberOrString::String("MD096".into()))) }) }) .expect("MD096 quick fix"); let edit = &quick_fix.edit.as_ref().unwrap().changes.as_ref().unwrap()[&uri][0]; assert_eq!(edit.range.start, Position::new(2, 0)); assert_eq!(edit.range.end, Position::new(4, 0)); assert_eq!(edit.new_text, "|Alpha|1|\n|Zulu|2|\n"); // Editor formatting/fix-all uses the same converging coordinator as CLI. let fixed = server.apply_all_fixes(&uri, input).await.unwrap().unwrap(); assert!(fixed.starts_with('\u{feff}')); assert!(fixed.find("| Alpha").unwrap() < fixed.find("| Zulu").unwrap()); assert!(server.apply_all_fixes(&uri, &fixed).await.unwrap().is_none()); // Diagnostic code actions can contain overlapping edits from two rules. // Applying successive fix-all actions must preserve records and converge. let mut current = input.to_string(); for _ in 0..3 { let actions = server.get_code_actions(&uri, ¤t, range).await.unwrap(); let Some(action) = actions.iter().find(|action| { action .kind .as_ref() .is_some_and(|kind| kind.as_str() == "source.fixAll.rumdl") }) else { break; }; current.clone_from(&action.edit.as_ref().unwrap().changes.as_ref().unwrap()[&uri][0].new_text); } assert_eq!(current, fixed); } /// Build an absolute, cross-platform path for navigation/hover/rename tests. /// /// A hardcoded `/tmp/...` literal is not an absolute path on Windows (it lacks a /// drive letter), so `Url::from_file_path` rejects it and the test panics during /// setup. Routing the suffix through `std::env::temp_dir()` yields a valid /// absolute path on every platform. These paths are used only as in-memory /// document and workspace-index keys; no files are created on disk. fn test_temp_path(suffix: &str) -> std::path::PathBuf { std::env::temp_dir().join(suffix) } #[test] fn test_is_valid_rule_name() { // Valid rule names - canonical MDxxx format assert!(is_valid_rule_name("MD001")); assert!(is_valid_rule_name("md001")); // lowercase assert!(is_valid_rule_name("Md001")); // mixed case assert!(is_valid_rule_name("mD001")); // mixed case assert!(is_valid_rule_name("MD003")); assert!(is_valid_rule_name("MD005")); assert!(is_valid_rule_name("MD007")); assert!(is_valid_rule_name("MD009")); assert!(is_valid_rule_name("MD041")); assert!(is_valid_rule_name("MD060")); assert!(is_valid_rule_name("MD061")); // Valid rule names - special "all" value assert!(is_valid_rule_name("all")); assert!(is_valid_rule_name("ALL")); assert!(is_valid_rule_name("All")); // Valid rule names - aliases (new in shared implementation) assert!(is_valid_rule_name("line-length")); // alias for MD013 assert!(is_valid_rule_name("LINE-LENGTH")); // case insensitive assert!(is_valid_rule_name("heading-increment")); // alias for MD001 assert!(is_valid_rule_name("no-bare-urls")); // alias for MD034 assert!(is_valid_rule_name("ul-style")); // alias for MD004 assert!(is_valid_rule_name("ul_style")); // underscore variant // Invalid rule names - not in alias map assert!(!is_valid_rule_name("MD000")); // doesn't exist assert!(!is_valid_rule_name("MD999")); // doesn't exist assert!(!is_valid_rule_name("MD100")); // doesn't exist assert!(!is_valid_rule_name("INVALID")); assert!(!is_valid_rule_name("not-a-rule")); assert!(!is_valid_rule_name("")); assert!(!is_valid_rule_name("random-text")); } #[tokio::test] async fn test_server_creation() { let server = create_test_server(); // Verify default configuration let config = server.config.read().await; assert!(config.enable_linting); assert!(!config.enable_auto_fix); } #[tokio::test] async fn test_lint_document() { let server = create_test_server(); // Test linting with a simple markdown document let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\nThis is a test \nWith trailing spaces "; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // Should find trailing spaces violations assert!(!diagnostics.is_empty()); assert!(diagnostics.iter().any(|d| d.message.contains("trailing"))); } #[tokio::test] async fn test_lint_document_disabled() { let server = create_test_server(); // Disable linting server.config.write().await.enable_linting = false; let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\nThis is a test \nWith trailing spaces "; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // Should return empty diagnostics when disabled assert!(diagnostics.is_empty()); } /// An inline directive naming a rule rumdl does not know silently does nothing. /// The CLI prints that on stderr; an editor only shows diagnostics, so the server /// reports it as one on the line that holds the comment. #[tokio::test] async fn test_inline_config_typo_is_a_diagnostic() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "# Title\n\nSome text.\n"; let diagnostics = server.lint_document(&uri, text, false).await.unwrap(); let inline: Vec<_> = diagnostics .iter() .filter(|d| d.code == Some(NumberOrString::String("inline-config".to_string()))) .collect(); assert_eq!( inline.len(), 1, "the unknown rule name should raise exactly one diagnostic, got: {diagnostics:?}" ); let diagnostic = inline[0]; assert!( diagnostic .message .contains("Unknown rule in inline disable-line comment: asdf"), "the diagnostic should name the directive and the unknown rule, got: {}", diagnostic.message ); assert_eq!(diagnostic.severity, Some(DiagnosticSeverity::WARNING)); assert_eq!(diagnostic.source.as_deref(), Some("rumdl")); // Third line of the document (0-indexed 2), spanning its full width. assert_eq!(diagnostic.range.start, Position { line: 2, character: 0 }); assert_eq!( diagnostic.range.end, Position { line: 2, character: "Some text.".chars().count() as u32, } ); } /// The same document with the rule name spelled correctly raises nothing, so the /// diagnostic above cannot be an artifact of having an inline comment at all. #[tokio::test] async fn test_valid_inline_config_is_not_a_diagnostic() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "# Title\n\nSome text.\n"; let diagnostics = server.lint_document(&uri, text, false).await.unwrap(); assert!( !diagnostics .iter() .any(|d| d.code == Some(NumberOrString::String("inline-config".to_string()))), "a correctly spelled directive should raise no inline-config diagnostic, got: {diagnostics:?}" ); } /// Configuration decides the rule set, and an inline enable cannot bring back a /// rule it disabled. The server reports that no-op the way the CLI does. #[tokio::test] async fn test_inline_enable_of_a_disabled_rule_is_a_diagnostic() { let server = create_test_server(); server.rumdl_config.write().await.global.disable = vec!["MD009".to_string()]; let uri = Url::parse("file:///test.md").unwrap(); // One trailing space, which MD009 flags; two would be a valid hard break. let text = "# Title\n\n\n\nText. \n"; let diagnostics = server.lint_document(&uri, text, false).await.unwrap(); assert!( diagnostics .iter() .any(|d| d.message.contains("MD009") && d.message.contains("has no effect")), "an inline enable of a config-disabled rule should say it has no effect, got: {diagnostics:?}" ); } /// A server whose per-file-ignores are the ones given here, and a URI it can turn /// back into a path to match them against. /// /// Both halves matter. `file:///test.md` carries no drive letter, so Windows /// cannot resolve it to a path and the server has nothing to match a pattern /// against; routing through `test_temp_path` gives an absolute path on every /// platform. Declaring the configuration explicit then keeps per-file discovery /// from replacing these patterns with whatever config file happens to sit above /// the temporary directory. async fn server_ignoring_md009(pattern: &str) -> (RumdlLanguageServer, Url) { let server = create_test_server(); server.config.write().await.config_path = Some("rumdl.toml".to_string()); server .rumdl_config .write() .await .per_file_ignores .insert(pattern.to_string(), vec!["MD009".to_string()]); (server, Url::from_file_path(test_temp_path("test.md")).unwrap()) } /// per-file-ignores drops a rule for one file with the same finality, so an /// inline enable is equally a no-op there. The diagnostic names that setting /// rather than a config-level disable the user does not have set. #[tokio::test] async fn test_inline_enable_of_a_per_file_ignored_rule_is_a_diagnostic() { let (server, uri) = server_ignoring_md009("*.md").await; // One trailing space, which MD009 flags; two would be a valid hard break. let text = "# Title\n\n\n\nText. \n"; let diagnostics = server.lint_document(&uri, text, false).await.unwrap(); assert!( diagnostics .iter() .any(|d| d.message.contains("MD009") && d.message.contains("per-file-ignores")), "the diagnostic should name per-file-ignores, got: {diagnostics:?}" ); assert!( !diagnostics .iter() .any(|d| d.code == Some(NumberOrString::String("MD009".to_string()))), "the ignored rule must not also report findings, got: {diagnostics:?}" ); } /// The control for the pattern: one that does not cover this file leaves the /// enable alone and lets the rule run. #[tokio::test] async fn test_inline_enable_under_an_unrelated_ignore_pattern_is_silent() { let (server, uri) = server_ignoring_md009("other.md").await; // One trailing space, which MD009 flags; two would be a valid hard break. let text = "# Title\n\n\n\nText. \n"; let diagnostics = server.lint_document(&uri, text, false).await.unwrap(); assert!( !diagnostics.iter().any(|d| d.message.contains("has no effect")), "a pattern that does not cover this file must not warn, got: {diagnostics:?}" ); assert!( diagnostics .iter() .any(|d| d.code == Some(NumberOrString::String("MD009".to_string()))), "the rule should still run, got: {diagnostics:?}" ); } /// A server whose configuration is explicit, so per-file discovery cannot replace /// the patterns given to the test. async fn explicit_config_server() -> RumdlLanguageServer { let server = create_test_server(); server.config.write().await.config_path = Some("rumdl.toml".to_string()); server } fn has_rule(diagnostics: &[Diagnostic], rule: &str) -> bool { diagnostics .iter() .any(|d| d.code == Some(NumberOrString::String(rule.to_string()))) } /// An unsaved buffer names no file, so per-file-ignores match it by its URI, the /// way `--stdin-filename untitled:Untitled-2` does on the command line. #[tokio::test] async fn test_per_file_ignores_match_an_untitled_buffer_by_uri() { let server = explicit_config_server().await; server .rumdl_config .write() .await .per_file_ignores .insert("untitled:Untitled-*".to_string(), vec!["MD041".to_string()]); let text = "no heading here\n"; let ignored = server .lint_document(&Url::parse("untitled:Untitled-2").unwrap(), text, false) .await .unwrap(); assert!( !has_rule(&ignored, "MD041"), "matched buffer must be ignored: {ignored:?}" ); // Controls: a buffer the pattern does not cover, and a saved file. let other = server .lint_document(&Url::parse("untitled:Scratch").unwrap(), text, false) .await .unwrap(); assert!(has_rule(&other, "MD041"), "unmatched buffer must report: {other:?}"); let saved = server .lint_document(&Url::from_file_path(test_temp_path("note.md")).unwrap(), text, false) .await .unwrap(); assert!(has_rule(&saved, "MD041"), "saved file must report: {saved:?}"); } /// A path pattern does not cover a URI that is not a path. #[tokio::test] async fn test_path_style_ignore_pattern_does_not_cover_an_untitled_buffer() { let server = explicit_config_server().await; server .rumdl_config .write() .await .per_file_ignores .insert("**/scratch-*.md".to_string(), vec!["MD041".to_string()]); let diagnostics = server .lint_document(&Url::parse("untitled:Untitled-2").unwrap(), "no heading here\n", false) .await .unwrap(); assert!(has_rule(&diagnostics, "MD041"), "got: {diagnostics:?}"); } /// Fix-all, code actions and formatting resolve per-file-ignores the same way /// diagnostics do, so an ignored rule is neither reported nor fixed. #[tokio::test] async fn test_untitled_buffer_per_file_ignores_apply_to_fixes_and_actions() { let server = explicit_config_server().await; server .rumdl_config .write() .await .per_file_ignores .insert("untitled:Untitled-*".to_string(), vec!["MD009".to_string()]); // One trailing space, which MD009 flags and fixes. let text = "# Title\n\nText. \n"; let ignored = Url::parse("untitled:Untitled-2").unwrap(); let other = Url::parse("untitled:Scratch").unwrap(); assert_eq!(server.apply_all_fixes(&ignored, text).await.unwrap(), None); assert!(server.apply_all_fixes(&other, text).await.unwrap().is_some()); let whole = Range::new(Position::new(0, 0), Position::new(3, 0)); let actions = server.get_code_actions(&ignored, text, whole).await.unwrap(); assert!( actions.iter().all(|a| !a.title.contains("MD009")), "ignored rule offers no action: {actions:?}" ); let actions = server.get_code_actions(&other, text, whole).await.unwrap(); assert!( actions.iter().any(|a| a.title.contains("MD009")), "control: {actions:?}" ); } /// The merge-conflict guard is itself a rule per-file-ignores can switch off, so /// it matches an untitled buffer by URI like every other rule does. #[tokio::test] async fn test_untitled_buffer_per_file_ignore_switches_off_the_conflict_guard() { let server = explicit_config_server().await; server .rumdl_config .write() .await .per_file_ignores .insert("untitled:Untitled-*".to_string(), vec!["MD092".to_string()]); let text = "# Title\n\n<<<<<<< HEAD\nours\n=======\ntheirs\n>>>>>>> branch\n\nText. \n"; let ignored = Url::parse("untitled:Untitled-2").unwrap(); let other = Url::parse("untitled:Scratch").unwrap(); assert!( !has_rule(&server.lint_document(&ignored, text, false).await.unwrap(), "MD092"), "the ignored guard must not report" ); assert!(has_rule( &server.lint_document(&other, text, false).await.unwrap(), "MD092" )); assert!(server.apply_all_fixes(&ignored, text).await.unwrap().is_some()); assert_eq!(server.apply_all_fixes(&other, text).await.unwrap(), None); let whole = Range::new(Position::new(0, 0), Position::new(9, 0)); let actions = server.get_code_actions(&ignored, text, whole).await.unwrap(); assert!(actions.iter().any(|a| a.title.contains("MD009")), "got: {actions:?}"); assert!(server.get_code_actions(&other, text, whole).await.unwrap().is_empty()); for uri in [&ignored, &other] { server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.into(), version: Some(1), from_disk: false, }, ); } let options = FormattingOptions::default(); let (original, formatted) = server.format_document(&ignored, &options).await.unwrap(); assert_ne!(original, formatted, "the ignored guard must not block formatting"); let (original, formatted) = server.format_document(&other, &options).await.unwrap(); assert_eq!(original, formatted, "the guard blocks formatting a conflicted buffer"); } /// `exclude` patterns match an untitled buffer by its URI too. #[tokio::test] async fn test_exclude_matches_an_untitled_buffer_by_uri() { let server = explicit_config_server().await; server .rumdl_config .write() .await .global .exclude .push("untitled:Untitled-*".to_string()); let text = "no heading here\n"; let excluded = Url::parse("untitled:Untitled-2").unwrap(); assert!(server.should_exclude_uri(&excluded).await); assert!( server.lint_document(&excluded, text, false).await.unwrap().is_empty(), "an excluded buffer gets no diagnostics" ); let other = Url::parse("untitled:Scratch").unwrap(); assert!(!server.should_exclude_uri(&other).await); assert!(has_rule( &server.lint_document(&other, text, false).await.unwrap(), "MD041" )); } #[tokio::test] async fn test_get_code_actions() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\nThis is a test \nWith trailing spaces "; // Create a range covering the whole document let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 3, character: 21 }, }; let actions = server.get_code_actions(&uri, text, range).await.unwrap(); // Should have code actions for fixing trailing spaces assert!(!actions.is_empty()); assert!(actions.iter().any(|a| a.title.contains("trailing"))); } #[tokio::test] async fn test_source_fix_all_with_single_fixable_issue() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); // Content with exactly 1 fixable issue: missing final newline (MD047) let text = "# Test"; let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 6 }, }; let actions = server.get_code_actions(&uri, text, range).await.unwrap(); let fix_all_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .collect(); assert!( !fix_all_actions.is_empty(), "source.fixAll.rumdl should be available even with a single fixable issue" ); } #[tokio::test] async fn fix_all_behind_a_byte_order_mark_edits_the_right_text_and_keeps_the_mark() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "\u{feff}# Title\n\nbody \n\n\n\nend\n"; let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 8 }, }; let actions = server.get_code_actions(&uri, text, range).await.unwrap(); let fix_all = actions .iter() .find(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .expect("a fix-all action"); let edit = &fix_all.edit.as_ref().unwrap().changes.as_ref().unwrap()[&uri][0]; assert_eq!(edit.new_text, "\u{feff}# Title\n\nbody\n\nend\n"); } #[test] fn fence_language_completion_works_behind_a_byte_order_mark() { let plain = RumdlLanguageServer::detect_code_fence_language_position( "```py\ncode\n```\n", Position { line: 0, character: 5 }, ); let marked = RumdlLanguageServer::detect_code_fence_language_position( "\u{feff}```py\ncode\n```\n", Position { line: 0, character: 6 }, ); assert_eq!(plain, Some((3, "py".to_string()))); assert_eq!(marked, Some((4, "py".to_string()))); // A mark in front of a later fence is ordinary text, so it is no fence. let later = RumdlLanguageServer::detect_code_fence_language_position( "# T\n\n\u{feff}```py\ncode\n```\n", Position { line: 2, character: 6 }, ); assert_eq!(later, None); } #[tokio::test] async fn test_get_code_actions_outside_range() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); // Lines 2 and 3 (0-indexed LSP line) have hard tabs (MD010, fixable), range only covers line 0. // Tabs are placed mid-line in paragraph text (not at column 0 after a blank line, // which would be an indented code block skipped by default with code_blocks=false). let text = "# Test\n\nThis is\ta test\nWith\ttabs\n"; // Range that doesn't cover the violations (line 0 only) let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 6 }, }; let actions = server.get_code_actions(&uri, text, range).await.unwrap(); // Per-warning actions should not appear for this range let per_warning_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() != "source.fixAll.rumdl")) .collect(); assert!( per_warning_actions.is_empty(), "No per-warning actions for out-of-range lines" ); // source.fixAll.rumdl is document-wide, so it should still appear let fix_all_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .collect(); assert!( !fix_all_actions.is_empty(), "fixAll is document-wide and should appear regardless of requested range" ); } #[tokio::test] async fn test_document_storage() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test Document"; // Store document let entry = DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }; server.documents.write().await.insert(uri.clone(), entry); // Verify storage let stored = server.documents.read().await.get(&uri).map(|e| e.content.clone()); assert_eq!(stored, Some(text.to_string())); // Remove document server.documents.write().await.remove(&uri); // Verify removal let stored = server.documents.read().await.get(&uri).cloned(); assert_eq!(stored, None); } #[tokio::test] async fn test_configuration_loading() { let server = create_test_server(); // Load configuration with auto-discovery server.load_configuration(false).await; // Verify configuration was loaded successfully // The config could be from: .rumdl.toml, pyproject.toml, .markdownlint.json, or default let rumdl_config = server.rumdl_config.read().await; // The loaded config is valid regardless of source drop(rumdl_config); // Just verify we can access it without panic } #[tokio::test] async fn test_load_config_for_lsp() { // Test with no config file let result = RumdlLanguageServer::load_config_for_lsp(None, None, None, None); assert!(result.is_ok()); // Test with non-existent config file let result = RumdlLanguageServer::load_config_for_lsp(Some("/nonexistent/config.toml"), None, None, None); assert!(result.is_err()); } /// The LSP workspace-load path (auto-discovery from the workspace root) must carry /// the same shadowed-config warning the CLI does, so `load_configuration` can /// surface it to editor users. Pins CLI/LSP parity on the shared discovery helper. #[test] fn test_lsp_discovery_carries_shadowed_config_warning() { use tempfile::tempdir; let temp = tempdir().unwrap(); std::fs::create_dir_all(temp.path().join(".git")).unwrap(); // bound discovery here std::fs::write(temp.path().join(".rumdl.toml"), "line-length = 11\n").unwrap(); std::fs::write(temp.path().join("rumdl.toml"), "line-length = 22\n").unwrap(); let root = temp.path().resolve_like_server(); let sourced = RumdlLanguageServer::load_config_for_lsp(None, Some(&root), None, None).expect("config should load"); assert!( sourced .discovery_warnings .iter() .any(|w| w.contains("multiple rumdl config files")), "LSP discovery should record a shadowed-config warning, got: {:?}", sourced.discovery_warnings ); } #[tokio::test] async fn test_warning_conversion() { let warning = LintWarning { message: "Test warning".to_string(), line: 1, column: 1, end_line: 1, end_column: 10, severity: crate::rule::Severity::Warning, fix: None, rule_name: Some("MD001".to_string()), }; // Test diagnostic conversion let diagnostic = warning_to_diagnostic(&warning, "Test content"); assert_eq!(diagnostic.message, "Test warning"); assert_eq!(diagnostic.severity, Some(DiagnosticSeverity::WARNING)); assert_eq!(diagnostic.code, Some(NumberOrString::String("MD001".to_string()))); // Test code action conversion (no fix, but should have ignore action) let uri = Url::parse("file:///test.md").unwrap(); let actions = warning_to_code_actions(&warning, &uri, "Test content"); // Should have 1 action: ignore-line (no fix available) assert_eq!(actions.len(), 1); assert_eq!(actions[0].title, "Ignore heading-increment (MD001) for this line"); } #[tokio::test] async fn test_multiple_documents() { let server = create_test_server(); let uri1 = Url::parse("file:///test1.md").unwrap(); let uri2 = Url::parse("file:///test2.md").unwrap(); let text1 = "# Document 1"; let text2 = "# Document 2"; // Store multiple documents { let mut docs = server.documents.write().await; let entry1 = DocumentEntry { content: text1.to_string(), version: Some(1), from_disk: false, }; let entry2 = DocumentEntry { content: text2.to_string(), version: Some(1), from_disk: false, }; docs.insert(uri1.clone(), entry1); docs.insert(uri2.clone(), entry2); } // Verify both are stored let docs = server.documents.read().await; assert_eq!(docs.len(), 2); assert_eq!(docs.get(&uri1).map(|s| s.content.as_str()), Some(text1)); assert_eq!(docs.get(&uri2).map(|s| s.content.as_str()), Some(text2)); } #[tokio::test] async fn test_auto_fix_on_save() { let server = create_test_server(); // Enable auto-fix { let mut config = server.config.write().await; config.enable_auto_fix = true; } let uri = Url::parse("file:///test.md").unwrap(); let text = "#Heading without space"; // MD018 violation // Store document let entry = DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }; server.documents.write().await.insert(uri.clone(), entry); // Test apply_all_fixes let fixed = server.apply_all_fixes(&uri, text).await.unwrap(); assert!(fixed.is_some()); // MD018 adds space, MD047 adds trailing newline assert_eq!(fixed.unwrap(), "# Heading without space\n"); } #[tokio::test] async fn test_get_end_position() { let server = create_test_server(); // Single line let pos = server.get_end_position("Hello"); assert_eq!(pos.line, 0); assert_eq!(pos.character, 5); // Multiple lines let pos = server.get_end_position("Hello\nWorld\nTest"); assert_eq!(pos.line, 2); assert_eq!(pos.character, 4); // Empty string let pos = server.get_end_position(""); assert_eq!(pos.line, 0); assert_eq!(pos.character, 0); // Ends with newline - position should be at start of next line let pos = server.get_end_position("Hello\n"); assert_eq!(pos.line, 1); assert_eq!(pos.character, 0); } #[tokio::test] async fn test_empty_document_handling() { let server = create_test_server(); let uri = Url::parse("file:///empty.md").unwrap(); let text = ""; // Test linting empty document let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); assert!(diagnostics.is_empty()); // Test code actions on empty document let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 0 }, }; let actions = server.get_code_actions(&uri, text, range).await.unwrap(); assert!(actions.is_empty()); } #[tokio::test] async fn test_config_update() { let server = create_test_server(); // Update config { let mut config = server.config.write().await; config.enable_auto_fix = true; config.config_path = Some("/custom/path.toml".to_string()); } // Verify update let config = server.config.read().await; assert!(config.enable_auto_fix); assert_eq!(config.config_path, Some("/custom/path.toml".to_string())); } #[tokio::test] async fn test_document_formatting() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\nThis is a test \nWith trailing spaces "; // Store document let entry = DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }; server.documents.write().await.insert(uri.clone(), entry); // Create formatting params let params = DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }, work_done_progress_params: WorkDoneProgressParams::default(), }; // Call formatting let result = server.formatting(params).await.unwrap(); // Should return text edits that fix the trailing spaces assert!(result.is_some()); let edits = result.unwrap(); assert!(!edits.is_empty()); let edit = &edits[0]; // The formatted text should have: // - Trailing spaces removed except where they are a hard break // - Exactly one final newline (trim_final_newlines + insert_final_newline) // The first line's two spaces are a hard break inside the paragraph and // stay; the last line's render as nothing and go. let expected = "# Test\n\nThis is a test \nWith trailing spaces\n"; assert_eq!(edit.new_text, expected); } #[tokio::test] async fn test_document_symbol_outline() { let server = create_test_server(); *server.client_supports_hierarchical_symbols.write().await = true; let uri = Url::parse("file:///outline.md").unwrap(); let text = "# Top\n\n## Child A\n\nbody\n\n## Child B\n\n### Grandchild\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; let result = server.document_symbol(params).await.unwrap(); let Some(DocumentSymbolResponse::Nested(symbols)) = result else { panic!("expected nested document symbols, got {result:?}"); }; assert_eq!(symbols.len(), 1, "single H1 root"); assert_eq!(symbols[0].name, "Top"); let children = symbols[0].children.as_ref().expect("Top has children"); assert_eq!(children.len(), 2); assert_eq!(children[0].name, "Child A"); assert_eq!(children[1].name, "Child B"); let grandchildren = children[1].children.as_ref().expect("Child B has a child"); assert_eq!(grandchildren[0].name, "Grandchild"); } #[tokio::test] async fn document_symbols_include_a_first_line_heading_behind_a_byte_order_mark() { let server = create_test_server(); *server.client_supports_hierarchical_symbols.write().await = true; let uri = Url::parse("file:///marked-outline.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "\u{feff}# Top\n\n## Child\n".to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; let result = server.document_symbol(params).await.unwrap(); let Some(DocumentSymbolResponse::Nested(symbols)) = result else { panic!("expected nested document symbols, got {result:?}"); }; assert_eq!(symbols.len(), 1); assert_eq!(symbols[0].name, "Top"); assert_eq!(symbols[0].selection_range.start.character, 3); assert_eq!(symbols[0].selection_range.end.character, 6); assert_eq!(symbols[0].children.as_ref().expect("Top has a child")[0].name, "Child"); } #[tokio::test] async fn test_document_symbol_flat_for_non_hierarchical_client() { // A client that does not advertise hierarchical support gets the legacy flat // form, with each heading's parent recorded as its container. let server = create_test_server(); assert!( !*server.client_supports_hierarchical_symbols.read().await, "default is the flat form" ); let uri = Url::parse("file:///flat.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "# Top\n\n## Child\n".to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; let result = server.document_symbol(params).await.unwrap(); let Some(DocumentSymbolResponse::Flat(symbols)) = result else { panic!("expected flat document symbols, got {result:?}"); }; assert_eq!(symbols.len(), 2); assert_eq!(symbols[0].name, "Top"); assert_eq!(symbols[0].container_name, None, "the top heading has no container"); assert_eq!(symbols[1].name, "Child"); assert_eq!( symbols[1].container_name.as_deref(), Some("Top"), "Child is contained by Top" ); } #[tokio::test] async fn test_document_symbol_none_without_headings() { let server = create_test_server(); let uri = Url::parse("file:///plain.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "just paragraphs\n\nno headings here\n".to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; assert!( server.document_symbol(params).await.unwrap().is_none(), "no symbols for a document without headings" ); } #[tokio::test] async fn test_workspace_symbol_search() { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let server = create_test_server(); let doc_path = std::env::temp_dir().join("rumdl-ws-symbol").join("doc.md"); { let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); let mut fi = FileIndex::default(); fi.headings.push(HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }); fi.headings.push(HeadingIndex { text: "Usage".to_string(), auto_anchor: "usage".to_string(), custom_anchor: None, line: 10, text_lines: 1, is_setext: false, }); index.insert_file(doc_path.clone(), fi); } let params = WorkspaceSymbolParams { query: "config".to_string(), work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; let symbols = server .symbol(params) .await .unwrap() .expect("expected workspace symbols"); assert_eq!(symbols.len(), 1, "only the matching heading is returned"); assert_eq!(symbols[0].name, "Configuration"); // Heading on line 3 (1-based) maps to LSP line 2 (0-based). assert_eq!(symbols[0].location.range.start.line, 2); assert!(symbols[0].location.uri.as_str().ends_with("doc.md")); } /// Test that Unfixable rules are excluded from formatting/Fix All but available for Quick Fix /// Regression test for issue #158: formatting deleted HTML img tags #[tokio::test] async fn test_unfixable_rules_excluded_from_formatting() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); // Content with both fixable (trailing spaces) and unfixable (HTML) issues let text = "# Test Document\n\n\"Test\"\n\nTrailing spaces "; // Store document let entry = DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }; server.documents.write().await.insert(uri.clone(), entry); // Test 1: Formatting should preserve HTML (Unfixable) but fix trailing spaces (fixable) let format_params = DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }, work_done_progress_params: WorkDoneProgressParams::default(), }; let format_result = server.formatting(format_params).await.unwrap(); assert!(format_result.is_some(), "Should return formatting edits"); let edits = format_result.unwrap(); assert!(!edits.is_empty(), "Should have formatting edits"); let formatted = &edits[0].new_text; assert!( formatted.contains("\"Test\""), "HTML should be preserved during formatting (Unfixable rule)" ); assert!( !formatted.contains("spaces "), "Trailing spaces should be removed (fixable rule)" ); // Test 2: Quick Fix actions should still be available for Unfixable rules let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 10, character: 0 }, }; let code_actions = server.get_code_actions(&uri, text, range).await.unwrap(); // Should have individual Quick Fix actions for each warning let html_fix_actions: Vec<_> = code_actions .iter() .filter(|action| action.title.contains("MD033") || action.title.contains("HTML")) .collect(); assert!( !html_fix_actions.is_empty(), "Quick Fix actions should be available for HTML (Unfixable rules)" ); // Test 3: "Fix All" action should exclude Unfixable rules let fix_all_actions: Vec<_> = code_actions .iter() .filter(|action| action.title.contains("Fix all")) .collect(); if let Some(fix_all_action) = fix_all_actions.first() && let Some(ref edit) = fix_all_action.edit && let Some(ref changes) = edit.changes && let Some(text_edits) = changes.get(&uri) && let Some(text_edit) = text_edits.first() { let fixed_all = &text_edit.new_text; assert!( fixed_all.contains("\"Test\""), "Fix All should preserve HTML (Unfixable rules)" ); assert!( !fixed_all.contains("spaces "), "Fix All should remove trailing spaces (fixable rules)" ); } } /// Test that resolve_config_for_file() finds the correct config in multi-root workspace #[tokio::test] async fn test_resolve_config_for_file_multi_root() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); // Setup project A with line_length=60 let project_a = temp_path.join("project_a"); let project_a_docs = project_a.join("docs"); fs::create_dir_all(&project_a_docs).unwrap(); let config_a = project_a.join(".rumdl.toml"); fs::write( &config_a, r#" [global] [MD013] line_length = 60 "#, ) .unwrap(); // Setup project B with line_length=120 let project_b = temp_path.join("project_b"); fs::create_dir(&project_b).unwrap(); let config_b = project_b.join(".rumdl.toml"); fs::write( &config_b, r#" [global] [MD013] line_length = 120 "#, ) .unwrap(); // Create LSP server and initialize with workspace roots let server = create_test_server(); // Set workspace roots { let mut roots = server.workspace_roots.write().await; roots.push(project_a.clone()); roots.push(project_b.clone()); } // Test file in project A let file_a = project_a_docs.join("test.md"); fs::write(&file_a, "# Test A\n").unwrap(); let config_for_a = server.resolve_config_for_file(&file_a).await; let line_length_a = crate::config::get_rule_config_value::(&config_for_a, "MD013", "line_length"); assert_eq!(line_length_a, Some(60), "File in project_a should get line_length=60"); // Test file in project B let file_b = project_b.join("test.md"); fs::write(&file_b, "# Test B\n").unwrap(); let config_for_b = server.resolve_config_for_file(&file_b).await; let line_length_b = crate::config::get_rule_config_value::(&config_for_b, "MD013", "line_length"); assert_eq!(line_length_b, Some(120), "File in project_b should get line_length=120"); } /// Test that config resolution respects workspace root boundaries #[tokio::test] async fn test_config_resolution_respects_workspace_boundaries() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); // Create parent config that should NOT be used let parent_config = temp_path.join(".rumdl.toml"); fs::write( &parent_config, r#" [global] [MD013] line_length = 80 "#, ) .unwrap(); // Create workspace root with its own config let workspace_root = temp_path.join("workspace"); let workspace_subdir = workspace_root.join("subdir"); fs::create_dir_all(&workspace_subdir).unwrap(); let workspace_config = workspace_root.join(".rumdl.toml"); fs::write( &workspace_config, r#" [global] [MD013] line_length = 100 "#, ) .unwrap(); let server = create_test_server(); // Register workspace_root as a workspace root { let mut roots = server.workspace_roots.write().await; roots.push(workspace_root.clone()); } // Test file deep in subdirectory let test_file = workspace_subdir.join("deep").join("test.md"); fs::create_dir_all(test_file.parent().unwrap()).unwrap(); fs::write(&test_file, "# Test\n").unwrap(); let config = server.resolve_config_for_file(&test_file).await; let line_length = crate::config::get_rule_config_value::(&config, "MD013", "line_length"); // Should find workspace_root/.rumdl.toml (100), NOT parent config (80) assert_eq!( line_length, Some(100), "Should find workspace config, not parent config outside workspace" ); } /// Test that config cache works (cache hit scenario) #[tokio::test] async fn test_config_cache_hit() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); let project = temp_path.join("project"); fs::create_dir(&project).unwrap(); let config_file = project.join(".rumdl.toml"); fs::write( &config_file, r#" [global] [MD013] line_length = 75 "#, ) .unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let test_file = project.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); // First call - cache miss let config1 = server.resolve_config_for_file(&test_file).await; let line_length1 = crate::config::get_rule_config_value::(&config1, "MD013", "line_length"); assert_eq!(line_length1, Some(75)); // Verify cache was populated { let cache = server.config_cache.read().await; let search_dir = test_file.parent().unwrap(); assert!( cache.contains_key(search_dir), "Cache should be populated after first call" ); } // Second call - cache hit (should return same config without filesystem access) let config2 = server.resolve_config_for_file(&test_file).await; let line_length2 = crate::config::get_rule_config_value::(&config2, "MD013", "line_length"); assert_eq!(line_length2, Some(75)); } /// Test nested directory config search (file searches upward) #[tokio::test] async fn test_nested_directory_config_search() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); let project = temp_path.join("project"); fs::create_dir(&project).unwrap(); // Config at project root let config = project.join(".rumdl.toml"); fs::write( &config, r#" [global] [MD013] line_length = 110 "#, ) .unwrap(); // File deep in nested structure let deep_dir = project.join("src").join("docs").join("guides"); fs::create_dir_all(&deep_dir).unwrap(); let deep_file = deep_dir.join("test.md"); fs::write(&deep_file, "# Test\n").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let resolved_config = server.resolve_config_for_file(&deep_file).await; let line_length = crate::config::get_rule_config_value::(&resolved_config, "MD013", "line_length"); assert_eq!( line_length, Some(110), "Should find config by searching upward from deep directory" ); } /// Test fallback to default config when no config file found #[tokio::test] async fn test_fallback_to_default_config() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); let project = temp_path.join("project"); fs::create_dir(&project).unwrap(); // No config file created! let test_file = project.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let config = server.resolve_config_for_file(&test_file).await; // Default global line_length is 80 assert_eq!( config.global.line_length.get(), 80, "Should fall back to default config when no config file found" ); } /// Test config priority: closer config wins over parent config #[tokio::test] async fn test_config_priority_closer_wins() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); let project = temp_path.join("project"); fs::create_dir(&project).unwrap(); // Parent config let parent_config = project.join(".rumdl.toml"); fs::write( &parent_config, r#" [global] [MD013] line_length = 100 "#, ) .unwrap(); // Subdirectory with its own config (should override parent) let subdir = project.join("subdir"); fs::create_dir(&subdir).unwrap(); let subdir_config = subdir.join(".rumdl.toml"); fs::write( &subdir_config, r#" [global] [MD013] line_length = 50 "#, ) .unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } // File in subdirectory let test_file = subdir.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let config = server.resolve_config_for_file(&test_file).await; let line_length = crate::config::get_rule_config_value::(&config, "MD013", "line_length"); assert_eq!( line_length, Some(50), "Closer config (subdir) should override parent config" ); } /// Test for issue #131: LSP should skip pyproject.toml without [tool.rumdl] section /// /// This test verifies the fix in resolve_config_for_file() at lines 574-585 that checks /// for [tool.rumdl] presence before loading pyproject.toml. The fix ensures LSP behavior /// matches CLI behavior. #[tokio::test] async fn test_issue_131_pyproject_without_rumdl_section() { use std::fs; use tempfile::tempdir; // Create a parent temp dir that we control let parent_dir = tempdir().unwrap(); // Create a child subdirectory for the project let project_dir = parent_dir.path().join("project"); fs::create_dir(&project_dir).unwrap(); // Create pyproject.toml WITHOUT [tool.rumdl] section in project dir fs::write( project_dir.join("pyproject.toml"), r#" [project] name = "test-project" version = "0.1.0" "#, ) .unwrap(); // Create .rumdl.toml in PARENT that SHOULD be found // because pyproject.toml without [tool.rumdl] should be skipped fs::write( parent_dir.path().join(".rumdl.toml"), r#" [global] disable = ["MD013"] "#, ) .unwrap(); let test_file = project_dir.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); // Set workspace root to parent so upward search doesn't stop at project_dir { let mut roots = server.workspace_roots.write().await; roots.push(parent_dir.path().to_path_buf()); } // Resolve config for file in project_dir let config = server.resolve_config_for_file(&test_file).await; // CRITICAL TEST: The pyproject.toml in project_dir should be SKIPPED because it lacks // [tool.rumdl], and the search should continue upward to find parent .rumdl.toml assert!( config.global.disable.contains(&"MD013".to_string()), "Issue #131 regression: LSP must skip pyproject.toml without [tool.rumdl] \ and continue upward search. Expected MD013 from parent .rumdl.toml to be disabled." ); // Verify the config came from the parent directory, not project_dir // (we can check this by looking at the cache) let cache = server.config_cache.read().await; let cache_entry = cache.get(&project_dir).expect("Config should be cached"); assert!( cache_entry.config_file.is_some(), "Should have found a config file (parent .rumdl.toml)" ); let found_config_path = cache_entry.config_file.as_ref().unwrap(); assert!( found_config_path.ends_with(".rumdl.toml"), "Should have loaded .rumdl.toml, not pyproject.toml. Found: {found_config_path:?}" ); assert!( found_config_path.parent().unwrap() == parent_dir.path(), "Should have loaded config from parent directory, not project_dir" ); } /// Test for issue #131: LSP should detect and load pyproject.toml WITH [tool.rumdl] section /// /// This test verifies that when pyproject.toml contains [tool.rumdl], the fix at lines 574-585 /// correctly allows it through and loads the configuration. #[tokio::test] async fn test_issue_131_pyproject_with_rumdl_section() { use std::fs; use tempfile::tempdir; // Create a parent temp dir that we control let parent_dir = tempdir().unwrap(); // Create a child subdirectory for the project let project_dir = parent_dir.path().join("project"); fs::create_dir(&project_dir).unwrap(); // Create pyproject.toml WITH [tool.rumdl] section in project dir fs::write( project_dir.join("pyproject.toml"), r#" [project] name = "test-project" [tool.rumdl.global] disable = ["MD033"] "#, ) .unwrap(); // Create a parent directory with different config that should NOT be used fs::write( parent_dir.path().join(".rumdl.toml"), r#" [global] disable = ["MD041"] "#, ) .unwrap(); let test_file = project_dir.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); // Set workspace root to parent { let mut roots = server.workspace_roots.write().await; roots.push(parent_dir.path().to_path_buf()); } // Resolve config for file let config = server.resolve_config_for_file(&test_file).await; // CRITICAL TEST: The pyproject.toml should be LOADED (not skipped) because it has [tool.rumdl] assert!( config.global.disable.contains(&"MD033".to_string()), "Issue #131 regression: LSP must load pyproject.toml when it has [tool.rumdl]. \ Expected MD033 from project_dir pyproject.toml to be disabled." ); // Verify we did NOT get the parent config assert!( !config.global.disable.contains(&"MD041".to_string()), "Should use project_dir pyproject.toml, not parent .rumdl.toml" ); // Verify the config came from pyproject.toml specifically let cache = server.config_cache.read().await; let cache_entry = cache.get(&project_dir).expect("Config should be cached"); assert!(cache_entry.config_file.is_some(), "Should have found a config file"); let found_config_path = cache_entry.config_file.as_ref().unwrap(); assert!( found_config_path.ends_with("pyproject.toml"), "Should have loaded pyproject.toml. Found: {found_config_path:?}" ); assert!( found_config_path.parent().unwrap() == project_dir, "Should have loaded pyproject.toml from project_dir, not parent" ); } /// Test for issue #131: Verify pyproject.toml with only "tool.rumdl" (no brackets) is detected /// /// The fix checks for both "[tool.rumdl]" and "tool.rumdl" (line 576), ensuring it catches /// any valid TOML structure like [tool.rumdl.global] or [[tool.rumdl.something]]. #[tokio::test] async fn test_issue_131_pyproject_with_tool_rumdl_subsection() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); // Create pyproject.toml with [tool.rumdl.global] but not [tool.rumdl] directly fs::write( temp_dir.path().join("pyproject.toml"), r#" [project] name = "test-project" [tool.rumdl.global] disable = ["MD022"] "#, ) .unwrap(); let test_file = temp_dir.path().join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); // Set workspace root { let mut roots = server.workspace_roots.write().await; roots.push(temp_dir.path().to_path_buf()); } // Resolve config for file let config = server.resolve_config_for_file(&test_file).await; // Should detect "tool.rumdl" substring and load the config assert!( config.global.disable.contains(&"MD022".to_string()), "Should detect tool.rumdl substring in [tool.rumdl.global] and load config" ); // Verify it loaded pyproject.toml let cache = server.config_cache.read().await; let cache_entry = cache.get(temp_dir.path()).expect("Config should be cached"); assert!( cache_entry.config_file.as_ref().unwrap().ends_with("pyproject.toml"), "Should have loaded pyproject.toml" ); } /// Test for issue #182: Client pull diagnostics capability detection /// /// When a client supports pull diagnostics (textDocument/diagnostic), the server /// should skip pushing diagnostics via publishDiagnostics to avoid duplicates. #[tokio::test] async fn test_issue_182_pull_diagnostics_capability_default() { let server = create_test_server(); // By default, client_supports_pull_diagnostics should be false assert!( !*server.client_supports_pull_diagnostics.read().await, "Default should be false - push diagnostics by default" ); } /// Test that we can set the pull diagnostics flag #[tokio::test] async fn test_issue_182_pull_diagnostics_flag_update() { let server = create_test_server(); // Simulate detecting pull capability *server.client_supports_pull_diagnostics.write().await = true; assert!( *server.client_supports_pull_diagnostics.read().await, "Flag should be settable to true" ); } /// Test issue #182: Verify capability detection logic matches Ruff's pattern /// /// The detection should check: params.capabilities.text_document.diagnostic.is_some() #[tokio::test] async fn test_issue_182_capability_detection_with_diagnostic_support() { use tower_lsp::lsp_types::{ClientCapabilities, DiagnosticClientCapabilities, TextDocumentClientCapabilities}; // Create client capabilities WITH diagnostic support let caps_with_diagnostic = ClientCapabilities { text_document: Some(TextDocumentClientCapabilities { diagnostic: Some(DiagnosticClientCapabilities { dynamic_registration: Some(true), related_document_support: Some(false), }), ..Default::default() }), ..Default::default() }; // Verify the detection logic (same as in initialize) let supports_pull = caps_with_diagnostic .text_document .as_ref() .and_then(|td| td.diagnostic.as_ref()) .is_some(); assert!(supports_pull, "Should detect pull diagnostic support"); } /// Test issue #182: Verify capability detection when diagnostic is NOT supported #[tokio::test] async fn test_issue_182_capability_detection_without_diagnostic_support() { use tower_lsp::lsp_types::{ClientCapabilities, TextDocumentClientCapabilities}; // Create client capabilities WITHOUT diagnostic support let caps_without_diagnostic = ClientCapabilities { text_document: Some(TextDocumentClientCapabilities { diagnostic: None, // No diagnostic support ..Default::default() }), ..Default::default() }; // Verify the detection logic let supports_pull = caps_without_diagnostic .text_document .as_ref() .and_then(|td| td.diagnostic.as_ref()) .is_some(); assert!(!supports_pull, "Should NOT detect pull diagnostic support"); } /// Test issue #182: Verify capability detection with empty text_document #[tokio::test] async fn test_issue_182_capability_detection_no_text_document() { use tower_lsp::lsp_types::ClientCapabilities; // Create client capabilities with no text_document at all let caps_no_text_doc = ClientCapabilities { text_document: None, ..Default::default() }; // Verify the detection logic let supports_pull = caps_no_text_doc .text_document .as_ref() .and_then(|td| td.diagnostic.as_ref()) .is_some(); assert!( !supports_pull, "Should NOT detect pull diagnostic support when text_document is None" ); } #[test] fn test_resource_limit_constants() { // Verify resource limit constants have expected values assert_eq!(MAX_RULE_LIST_SIZE, 100); assert_eq!(MAX_LINE_LENGTH, 10_000); } #[test] fn test_is_valid_rule_name_edge_cases() { // Test malformed MDxxx patterns - not in alias map assert!(!is_valid_rule_name("MD/01")); // invalid character assert!(!is_valid_rule_name("MD:01")); // invalid character assert!(!is_valid_rule_name("ND001")); // 'N' instead of 'M' assert!(!is_valid_rule_name("ME001")); // 'E' instead of 'D' // Test non-ASCII characters - not in alias map assert!(!is_valid_rule_name("MD0โ‘ 1")); // Unicode digit assert!(!is_valid_rule_name("๏ผญD001")); // Fullwidth M // Test special characters - not in alias map assert!(!is_valid_rule_name("MD\x00\x00\x00")); // null bytes } /// Generic parity test: LSP config must produce identical results to TOML config. /// /// This test ensures that ANY config field works identically whether applied via: /// 1. LSP settings (JSON -> apply_rule_config) /// 2. TOML file parsing (direct RuleConfig construction) /// /// When adding new config fields to RuleConfig, add them to TEST_CONFIGS below. /// The test will fail if LSP handling diverges from TOML handling. #[test] fn test_lsp_toml_config_parity_generic() { use crate::config::RuleConfig; use crate::rule::Severity; // Define test configurations covering all field types and combinations. // Each entry: (description, LSP JSON, expected TOML RuleConfig) // When adding new RuleConfig fields, add test cases here. let test_configs: Vec<(&str, serde_json::Value, RuleConfig)> = vec![ // Severity alone (the bug from issue #229) ( "severity only - error", serde_json::json!({"severity": "error"}), RuleConfig { severity: Some(Severity::Error), values: std::collections::BTreeMap::new(), }, ), ( "severity only - warning", serde_json::json!({"severity": "warning"}), RuleConfig { severity: Some(Severity::Warning), values: std::collections::BTreeMap::new(), }, ), ( "severity only - info", serde_json::json!({"severity": "info"}), RuleConfig { severity: Some(Severity::Info), values: std::collections::BTreeMap::new(), }, ), // Value types: integer ( "integer value", serde_json::json!({"lineLength": 120}), RuleConfig { severity: None, values: [("line_length".to_string(), toml::Value::Integer(120))] .into_iter() .collect(), }, ), // Value types: boolean ( "boolean value", serde_json::json!({"enabled": true}), RuleConfig { severity: None, values: [("enabled".to_string(), toml::Value::Boolean(true))] .into_iter() .collect(), }, ), // Value types: string ( "string value", serde_json::json!({"style": "consistent"}), RuleConfig { severity: None, values: [("style".to_string(), toml::Value::String("consistent".to_string()))] .into_iter() .collect(), }, ), // Value types: array ( "array value", serde_json::json!({"allowedElements": ["div", "span"]}), RuleConfig { severity: None, values: [( "allowed_elements".to_string(), toml::Value::Array(vec![ toml::Value::String("div".to_string()), toml::Value::String("span".to_string()), ]), )] .into_iter() .collect(), }, ), // Mixed: severity + values (critical combination) ( "severity + integer", serde_json::json!({"severity": "info", "lineLength": 80}), RuleConfig { severity: Some(Severity::Info), values: [("line_length".to_string(), toml::Value::Integer(80))] .into_iter() .collect(), }, ), ( "severity + multiple values", serde_json::json!({ "severity": "warning", "lineLength": 100, "strict": false, "style": "atx" }), RuleConfig { severity: Some(Severity::Warning), values: [ ("line_length".to_string(), toml::Value::Integer(100)), ("strict".to_string(), toml::Value::Boolean(false)), ("style".to_string(), toml::Value::String("atx".to_string())), ] .into_iter() .collect(), }, ), // camelCase to snake_case conversion ( "camelCase conversion", serde_json::json!({"codeBlocks": true, "headingStyle": "setext"}), RuleConfig { severity: None, values: [ ("code_blocks".to_string(), toml::Value::Boolean(true)), ("heading_style".to_string(), toml::Value::String("setext".to_string())), ] .into_iter() .collect(), }, ), ]; for (description, lsp_json, expected_toml_config) in test_configs { let mut lsp_config = crate::config::Config::default(); crate::lsp::configuration::apply_rule_config(&mut lsp_config, "TEST", &lsp_json); let lsp_rule = lsp_config.rules.get("TEST").expect("Rule should exist"); // Compare severity assert_eq!( lsp_rule.severity, expected_toml_config.severity, "Parity failure [{description}]: severity mismatch. \ LSP={:?}, TOML={:?}", lsp_rule.severity, expected_toml_config.severity ); // Compare values assert_eq!( lsp_rule.values, expected_toml_config.values, "Parity failure [{description}]: values mismatch. \ LSP={:?}, TOML={:?}", lsp_rule.values, expected_toml_config.values ); } } /// Test apply_rule_config_if_absent preserves all existing config #[test] fn test_lsp_config_if_absent_preserves_existing() { use crate::config::RuleConfig; use crate::rule::Severity; // Pre-existing file config with severity AND values let mut config = crate::config::Config::default(); config.rules.insert( "MD013".to_string(), RuleConfig { severity: Some(Severity::Error), values: [("line_length".to_string(), toml::Value::Integer(80))] .into_iter() .collect(), }, ); // LSP tries to override with different values let lsp_json = serde_json::json!({ "severity": "info", "lineLength": 120 }); crate::lsp::configuration::apply_rule_config_if_absent(&mut config, "MD013", &lsp_json); let rule = config.rules.get("MD013").expect("Rule should exist"); // Original severity preserved assert_eq!( rule.severity, Some(Severity::Error), "Existing severity should not be overwritten" ); // Original values preserved assert_eq!( rule.values.get("line_length"), Some(&toml::Value::Integer(80)), "Existing values should not be overwritten" ); } // Tests for apply_formatting_options (issue #265) #[test] fn test_apply_formatting_options_insert_final_newline() { let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: None, insert_final_newline: Some(true), trim_final_newlines: None, }; // Content without final newline should get one added let result = RumdlLanguageServer::apply_formatting_options( "hello".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\n"); // Content with final newline should stay the same let result = RumdlLanguageServer::apply_formatting_options( "hello\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\n"); } #[test] fn test_apply_formatting_options_trim_final_newlines() { let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: None, insert_final_newline: None, trim_final_newlines: Some(true), }; // Multiple trailing newlines should be removed let result = RumdlLanguageServer::apply_formatting_options( "hello\n\n\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello"); // Single trailing newline should also be removed (trim_final_newlines removes ALL) let result = RumdlLanguageServer::apply_formatting_options( "hello\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello"); } #[test] fn test_apply_formatting_options_trim_and_insert_combined() { // This is the common case: trim extra newlines, then ensure exactly one let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: None, insert_final_newline: Some(true), trim_final_newlines: Some(true), }; // Multiple trailing newlines -> exactly one let result = RumdlLanguageServer::apply_formatting_options( "hello\n\n\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\n"); // No trailing newline -> add one let result = RumdlLanguageServer::apply_formatting_options( "hello".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\n"); // Already has exactly one -> unchanged let result = RumdlLanguageServer::apply_formatting_options( "hello\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\n"); } #[test] fn test_apply_formatting_options_trim_trailing_whitespace() { let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: None, }; // Trailing whitespace on lines should be removed let result = RumdlLanguageServer::apply_formatting_options( "hello \nworld\t\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\nworld\n"); } /// Trimming trailing whitespace leaves the blank lines at the end of the /// document alone; removing them is `trim_final_newlines`' job. #[test] fn test_apply_formatting_options_trim_keeps_trailing_blank_lines() { let trim_only = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: None, trim_final_newlines: None, }; for (content, expected) in [ ("text\n\n", "text\n\n"), ("text \n\n\n", "text\n\n\n"), ("text\n \n", "text\n\n"), ("text \n", "text\n"), ("text ", "text"), ] { let result = RumdlLanguageServer::apply_formatting_options( content.to_string(), &trim_only, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, expected, "{content:?}"); } } /// Trimming trailing whitespace must not change what the document renders: /// two or more trailing spaces inside a continuing paragraph are a hard line /// break, and trailing whitespace in code, math, HTML and front matter is /// content. Everywhere else, including headings and the last line of a /// paragraph, trailing whitespace renders as nothing and is removed. #[test] fn test_apply_formatting_options_trim_keeps_rendered_whitespace() { let trim_only = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: None, trim_final_newlines: None, }; let format = |content: &str| { RumdlLanguageServer::apply_formatting_options( content.to_string(), &trim_only, crate::config::MarkdownFlavor::Standard, ) }; // Hard breaks stay, in a paragraph, a list item and a blockquote. assert_eq!(format("foo \nbar\n"), "foo \nbar\n"); assert_eq!(format("foo \nbar\n"), "foo \nbar\n"); assert_eq!(format("- foo \n bar\n"), "- foo \n bar\n"); assert_eq!(format("> foo \n> bar\n"), "> foo \n> bar\n"); // Verbatim content stays. let fenced = "```\ncode \ntab\t\n```\n"; assert_eq!(format(fenced), fenced); let front_matter = "---\ntitle: x \n---\n\nText\n"; assert_eq!(format(front_matter), front_matter); let html = "
\n inner \n
\n"; assert_eq!(format(html), html); // Whitespace that renders as nothing goes. assert_eq!(format("# Heading \n\nText \n"), "# Heading\n\nText\n"); assert_eq!(format("foo \nbar\n"), "foo\nbar\n"); assert_eq!(format("foo\t\nbar\n"), "foo\nbar\n"); assert_eq!(format("foo \n\nbar\n"), "foo\n\nbar\n"); assert_eq!(format("foo \n- item\n"), "foo\n- item\n"); assert_eq!(format(" \ntext\n"), "\ntext\n"); // CRLF documents get the same treatment and keep their endings. assert_eq!(format("foo \r\nbar \r\n"), "foo \r\nbar\r\n"); } #[test] fn test_apply_formatting_options_issue_265_scenario() { // Issue #265: MD012 at end of file doesn't work with LSP formatting // The editor (nvim) may strip trailing newlines from buffer before sending to LSP // With proper FormattingOptions handling, we should still get the right result let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: None, insert_final_newline: Some(true), trim_final_newlines: Some(true), }; // Scenario 1: Editor sends content with multiple trailing newlines let result = RumdlLanguageServer::apply_formatting_options( "hello foobar hello.\n\n\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!( result, "hello foobar hello.\n", "Should have exactly one trailing newline" ); // Scenario 2: Editor sends content with trailing newlines stripped let result = RumdlLanguageServer::apply_formatting_options( "hello foobar hello.".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello foobar hello.\n", "Should add final newline"); // Scenario 3: Content is already correct let result = RumdlLanguageServer::apply_formatting_options( "hello foobar hello.\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello foobar hello.\n", "Should remain unchanged"); } #[test] fn test_apply_formatting_options_no_options() { // When all options are None/false, content should be unchanged let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: None, insert_final_newline: None, trim_final_newlines: None, }; let content = "hello \nworld\n\n\n"; let result = RumdlLanguageServer::apply_formatting_options( content.to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, content, "Content should be unchanged when no options set"); } #[test] fn test_apply_formatting_options_empty_content() { let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }; // Empty content should stay empty (no newline added to truly empty documents) let result = RumdlLanguageServer::apply_formatting_options( "".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, ""); // Just newlines should become single newline (content existed, so gets final newline) let result = RumdlLanguageServer::apply_formatting_options( "\n\n\n".to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "\n"); } #[test] fn test_apply_formatting_options_multiline_content() { let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }; let content = "# Heading \n\nParagraph \n- List item \n\n\n"; let result = RumdlLanguageServer::apply_formatting_options( content.to_string(), &options, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "# Heading\n\nParagraph\n- List item\n"); } /// The formatting options are line-oriented and must leave a CRLF document /// CRLF. Each option used to be written for LF alone: trimming trailing /// whitespace rebuilt the document with `join("\n")`, trimming final newlines /// popped only `\n` (stranding the `\r` of the last `\r\n`), and inserting a /// final newline pushed a bare `\n`. #[test] fn test_apply_formatting_options_keep_crlf_line_endings() { let all = editor_formatting_options(); let content = "# Heading \r\n\r\nParagraph \r\n- List item \r\n\r\n\r\n"; let result = RumdlLanguageServer::apply_formatting_options( content.to_string(), &all, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "# Heading\r\n\r\nParagraph\r\n- List item\r\n"); let insert_only = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(false), insert_final_newline: Some(true), trim_final_newlines: Some(false), }; let result = RumdlLanguageServer::apply_formatting_options( "hello\r\nworld".to_string(), &insert_only, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\r\nworld\r\n"); let trim_final_only = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(false), insert_final_newline: Some(false), trim_final_newlines: Some(true), }; let result = RumdlLanguageServer::apply_formatting_options( "hello\r\n\r\n\r\n".to_string(), &trim_final_only, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello"); // A document the options leave alone comes back byte-identical. let result = RumdlLanguageServer::apply_formatting_options( "hello\r\nworld\r\n".to_string(), &all, crate::config::MarkdownFlavor::Standard, ); assert_eq!(result, "hello\r\nworld\r\n"); } #[test] fn test_code_action_kind_filtering() { // Test the hierarchical code action kind matching used in code_action handler // LSP spec: source.fixAll.rumdl should match requests for source.fixAll let matches = |action_kind: &str, requested: &str| -> bool { action_kind.starts_with(requested) }; // source.fixAll.rumdl matches source.fixAll (parent kind) assert!(matches("source.fixAll.rumdl", "source.fixAll")); // source.fixAll.rumdl matches source.fixAll.rumdl (exact match) assert!(matches("source.fixAll.rumdl", "source.fixAll.rumdl")); // source.fixAll.rumdl matches source (grandparent kind) assert!(matches("source.fixAll.rumdl", "source")); // quickfix matches quickfix (exact match) assert!(matches("quickfix", "quickfix")); // source.fixAll.rumdl does NOT match quickfix assert!(!matches("source.fixAll.rumdl", "quickfix")); // quickfix does NOT match source.fixAll assert!(!matches("quickfix", "source.fixAll")); // source.fixAll does NOT match source.fixAll.rumdl (child is more specific) assert!(!matches("source.fixAll", "source.fixAll.rumdl")); } #[test] fn test_code_action_kind_filter_with_empty_array() { // LSP spec: "If provided with no kinds, all supported kinds are returned" // An empty array should be treated the same as None (return all actions) let filter_actions = |kinds: Option>| -> bool { // Simulates our filtering logic if let Some(ref k) = kinds && !k.is_empty() { // Would filter false } else { // Return all true } }; // None returns all actions assert!(filter_actions(None)); // Empty array returns all actions (per LSP spec) assert!(filter_actions(Some(vec![]))); // Non-empty array triggers filtering assert!(!filter_actions(Some(vec!["source.fixAll"]))); } #[test] fn test_code_action_kind_constants() { // Verify our custom code action kind string matches LSP conventions let fix_all_rumdl = CodeActionKind::new("source.fixAll.rumdl"); assert_eq!(fix_all_rumdl.as_str(), "source.fixAll.rumdl"); // Verify it's a sub-kind of SOURCE_FIX_ALL assert!( fix_all_rumdl .as_str() .starts_with(CodeActionKind::SOURCE_FIX_ALL.as_str()) ); } // ==================== Completion Tests ==================== #[test] fn test_detect_code_fence_language_position_basic() { // Basic case: cursor right after ``` let text = "```\ncode\n```"; let pos = Position { line: 0, character: 3 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 3); assert_eq!(current_text, ""); } #[test] fn test_detect_code_fence_language_position_partial_lang() { // Cursor in the middle of typing a language let text = "```py\ncode\n```"; let pos = Position { line: 0, character: 5 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 3); assert_eq!(current_text, "py"); } #[test] fn test_detect_code_fence_language_position_full_lang() { // Cursor at end of language tag let text = "```python\ncode\n```"; let pos = Position { line: 0, character: 9 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 3); assert_eq!(current_text, "python"); } #[test] fn test_detect_code_fence_language_position_tilde_fence() { // Using ~~~ instead of ``` let text = "~~~rust\ncode\n~~~"; let pos = Position { line: 0, character: 7 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 3); assert_eq!(current_text, "rust"); } #[test] fn test_detect_code_fence_language_position_indented() { // Indented code fence let text = " ```js\ncode\n ```"; let pos = Position { line: 0, character: 7 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 5); // 2 spaces + 3 backticks assert_eq!(current_text, "js"); } #[test] fn test_detect_code_fence_language_position_not_fence_line() { // Not on a fence line (inside code block content) let text = "```python\ncode\n```"; let pos = Position { line: 1, character: 2 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_none()); } #[test] fn test_detect_code_fence_language_position_closing_fence() { // On closing fence - should NOT trigger completion let text = "```python\ncode\n```"; let pos = Position { line: 2, character: 3 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); // Closing fence should return None (no completion on closing fences) assert!(result.is_none(), "Should not offer completion on closing fence"); } #[test] fn test_detect_code_fence_language_position_extended_fence() { // Extended fence with 4 backticks let text = "````python\ncode\n````"; let pos = Position { line: 0, character: 10 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 4); // 4 backticks assert_eq!(current_text, "python"); } #[test] fn test_detect_code_fence_language_position_extended_fence_5_backticks() { // Extended fence with 5 backticks let text = "`````js\ncode\n`````"; let pos = Position { line: 0, character: 7 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 5); assert_eq!(current_text, "js"); } #[test] fn test_detect_code_fence_language_position_nested_code_blocks() { // Nested code block (documenting markdown in markdown) // Outer: 4 backticks, Inner: 3 backticks let text = "````markdown\n```python\ncode\n```\n````"; // Opening fence of outer block let pos = Position { line: 0, character: 12 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some()); let (_, current_text) = result.unwrap(); assert_eq!(current_text, "markdown"); // The inner fence is content of the outer block, not a fence of its own. let pos = Position { line: 1, character: 9 }; assert!(RumdlLanguageServer::detect_code_fence_language_position(text, pos).is_none()); } #[test] fn test_detect_code_fence_language_position_extended_closing_fence() { // Extended closing fence should not trigger completion let text = "````python\ncode here\n````"; let pos = Position { line: 2, character: 4 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!( result.is_none(), "Should not offer completion on extended closing fence" ); } #[test] fn test_detect_code_fence_language_position_cursor_before_fence() { // Cursor before the fence characters let text = "```python\ncode\n```"; let pos = Position { line: 0, character: 2 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_none()); } #[test] fn test_detect_code_fence_language_position_with_info_string() { // Info string with space (should not complete after space) let text = "```python filename.py\ncode\n```"; let pos = Position { line: 0, character: 15 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); // Should return None because cursor is after a space assert!(result.is_none()); } /// A fence opens a code block inside a blockquote or list item too, and the /// language completes at the column after the fence characters. #[test] fn test_detect_code_fence_language_position_in_containers() { for (text, line, col, start) in [ ("> ```py\n> code\n> ```\n", 0, 7, 5), ("- ```py\n code\n ```\n", 0, 7, 5), ("1. ```py\n code\n ```\n", 0, 8, 6), ("> - ```py\n> code\n", 0, 9, 7), ("- item\n\n > ~~~py\n", 2, 9, 7), ] { let pos = Position { line, character: col }; assert_eq!( RumdlLanguageServer::detect_code_fence_language_position(text, pos), Some((start, "py".to_string())), "{text:?}" ); } } /// Backticks in an indented code block, or on a closing fence inside a /// container, are not an opening fence. #[test] fn test_detect_code_fence_language_position_not_an_opener() { for (text, line, col) in [ ("Text.\n\n ```py\n", 2, 9), ("> ```py\n> code\n> ```\n", 2, 5), ("- ```py\n code\n ```\n", 2, 5), // Content of a tilde block, and a backtick line with an info string, // which cannot close a block and so is content too. ("~~~\n```py\n~~~\n", 1, 5), ("```\ncode\n```py\n", 2, 5), // Inline backticks, with a real fence further down. ("Text ```py here\n\n```js\n", 0, 10), ] { let pos = Position { line, character: col }; assert_eq!( RumdlLanguageServer::detect_code_fence_language_position(text, pos), None, "{text:?} line {line}" ); } } #[test] fn test_detect_code_fence_language_position_regular_text() { // Regular markdown text (not a code fence) let text = "# Heading\n\nSome text."; let pos = Position { line: 0, character: 5 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_none()); } #[test] fn test_detect_code_fence_language_position_non_ascii_language() { // "รฉ" is U+00E9: 2 UTF-8 bytes, 1 UTF-16 code unit. // "```rรฉsumรฉ" โ€” fence ends at byte/UTF-16 col 3. // "rรฉsumรฉ" = r(1)+รฉ(1)+s(1)+u(1)+m(1)+รฉ(1) = 6 UTF-16 units, 8 UTF-8 bytes. // UTF-16 cursor at 9 (3 + 6); byte offset is 11 (3 + 8). // Old code: &line[3..9] slices into the middle of the second รฉ โ†’ panic. // Fixed code: converts UTF-16 9 โ†’ byte 11 first. let text = "```rรฉsumรฉ"; let pos = Position { line: 0, character: 9 }; // UTF-16 cursor at end of "rรฉsumรฉ" let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_some(), "should detect fence language with non-ASCII text"); let (start_col, current_text) = result.unwrap(); assert_eq!(start_col, 3); // fence_end is always ASCII, so col == byte offset assert_eq!(current_text, "rรฉsumรฉ"); } #[test] fn test_detect_code_fence_language_position_inline_code() { // Inline code (not a fenced block) let text = "Use `code` here."; let pos = Position { line: 0, character: 5 }; let result = RumdlLanguageServer::detect_code_fence_language_position(text, pos); assert!(result.is_none()); } #[tokio::test] async fn test_completion_provides_language_items() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); fs::write(&test_file, "```py\ncode\n```").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(&test_file).unwrap(); // Open the document let content = "```py\ncode\n```".to_string(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.clone(), version: Some(1), from_disk: false, }, ); // Get completions at position after ``` let items = server .get_language_completions(&uri, "py", 3, Position { line: 0, character: 5 }) .await; // Should have python-related items assert!(!items.is_empty(), "Should return completion items"); // Check that python is in the results let has_python = items.iter().any(|item| item.label.to_lowercase() == "python"); assert!(has_python, "Should include 'python' as a completion item"); } #[tokio::test] async fn test_completion_filters_by_prefix() { let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); std::fs::write(&test_file, "```ru\ncode\n```").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(&test_file).unwrap(); // Get completions filtered by "ru" let items = server .get_language_completions(&uri, "ru", 3, Position { line: 0, character: 5 }) .await; // All items should start with "ru" for item in &items { assert!( item.label.to_lowercase().starts_with("ru"), "Completion '{}' should start with 'ru'", item.label ); } // Should include rust and ruby let has_rust = items.iter().any(|item| item.label.to_lowercase() == "rust"); let has_ruby = items.iter().any(|item| item.label.to_lowercase() == "ruby"); assert!(has_rust, "Should include 'rust'"); assert!(has_ruby, "Should include 'ruby'"); } #[tokio::test] async fn test_completion_empty_prefix_returns_all() { let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); std::fs::write(&test_file, "```\ncode\n```").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(&test_file).unwrap(); // Get completions with empty prefix let items = server .get_language_completions(&uri, "", 3, Position { line: 0, character: 3 }) .await; // Should have many items (up to the limit of 100) assert!(items.len() >= 10, "Should return multiple language options"); assert!(items.len() <= 100, "Should be limited to 100 items"); } #[tokio::test] async fn test_completion_respects_md040_allowed_languages() { use std::fs; let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); fs::write(&test_file, "```\ncode\n```").unwrap(); // Create config with allowed_languages let config_file = temp_dir.path().join(".rumdl.toml"); fs::write( &config_file, r#" [MD040] allowed-languages = ["Python", "Rust", "Go"] "#, ) .unwrap(); let server = create_test_server(); // Set workspace root so config is discovered { let mut roots = server.workspace_roots.write().await; roots.push(temp_dir.path().to_path_buf()); } let uri = Url::from_file_path(&test_file).unwrap(); // Get completions let items = server .get_language_completions(&uri, "", 3, Position { line: 0, character: 3 }) .await; // Should only have items for Python, Rust, Go and their aliases for item in &items { let label_lower = item.label.to_lowercase(); let detail = item.detail.as_ref().map_or_default(|d| d.to_lowercase()); // Check that the canonical language (in detail) is one of the allowed ones let is_allowed = detail.contains("python") || detail.contains("rust") || detail.contains("go"); assert!( is_allowed, "Completion '{label_lower}' (detail: '{detail}') should be for Python, Rust, or Go" ); } } #[tokio::test] async fn test_completion_respects_md040_disallowed_languages() { use std::fs; let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); fs::write(&test_file, "```py\ncode\n```").unwrap(); // Create config with disallowed_languages let config_file = temp_dir.path().join(".rumdl.toml"); fs::write( &config_file, r#" [MD040] disallowed-languages = ["Python"] "#, ) .unwrap(); let server = create_test_server(); // Set workspace root so config is discovered { let mut roots = server.workspace_roots.write().await; roots.push(temp_dir.path().to_path_buf()); } let uri = Url::from_file_path(&test_file).unwrap(); // Get completions filtered by "py" let items = server .get_language_completions(&uri, "py", 3, Position { line: 0, character: 5 }) .await; // Should NOT include Python or py for item in &items { let detail = item.detail.as_ref().map_or_default(|d| d.to_lowercase()); assert!( !detail.contains("python"), "Completion '{}' should not include Python (disallowed)", item.label ); } } /// A server whose config discovery sees `config` in a temp workspace, plus the /// URI of a markdown file in it. async fn server_with_md040_config(config: &str) -> (RumdlLanguageServer, Url, tempfile::TempDir) { let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); std::fs::write(&test_file, "```\ncode\n```").unwrap(); std::fs::write(temp_dir.path().join(".rumdl.toml"), config).unwrap(); let server = create_test_server(); server.workspace_roots.write().await.push(temp_dir.path().to_path_buf()); let uri = Url::from_file_path(&test_file).unwrap(); (server, uri, temp_dir) } #[tokio::test] async fn test_completion_offers_custom_languages() { let (server, uri, _dir) = server_with_md040_config("[MD040]\ncustom-languages = [\"cddl\"]\n").await; let items = server .get_language_completions(&uri, "cd", 3, Position { line: 0, character: 5 }) .await; let cddl = items .iter() .find(|item| item.label == "cddl") .expect("a declared custom language must be offered"); assert_eq!(cddl.detail.as_deref(), Some("cddl (custom-languages)")); // Control: the same label is not a language without the declaration. let (plain, plain_uri, _plain_dir) = server_with_md040_config("[MD040]\n").await; let items = plain .get_language_completions(&plain_uri, "cd", 3, Position { line: 0, character: 5 }) .await; assert!( !items.iter().any(|item| item.label == "cddl"), "an undeclared label must not be offered" ); } #[tokio::test] async fn test_completion_offers_custom_languages_with_an_empty_prefix() { // The result list is capped, so a custom language must not be pushed past the cap // by the hundreds of Linguist entries. let (server, uri, _dir) = server_with_md040_config("[MD040]\ncustom-languages = [\"cddl\"]\n").await; let items = server .get_language_completions(&uri, "", 3, Position { line: 0, character: 3 }) .await; assert!( items.iter().any(|item| item.label == "cddl"), "a custom language must survive the result cap" ); } #[tokio::test] async fn test_completion_applies_language_lists_to_custom_languages() { let (allowed, allowed_uri, _allowed_dir) = server_with_md040_config( "[MD040]\ncustom-languages = [\"cddl\", \"jsonnet\"]\nallowed-languages = [\"cddl\"]\n", ) .await; let items = allowed .get_language_completions(&allowed_uri, "", 3, Position { line: 0, character: 3 }) .await; assert!(items.iter().any(|item| item.label == "cddl")); assert!( !items.iter().any(|item| item.label == "jsonnet"), "a custom language outside the allowlist must not be offered" ); let (denied, denied_uri, _denied_dir) = server_with_md040_config("[MD040]\ncustom-languages = [\"cddl\"]\ndisallowed-languages = [\"cddl\"]\n").await; let items = denied .get_language_completions(&denied_uri, "", 3, Position { line: 0, character: 3 }) .await; assert!( !items.iter().any(|item| item.label == "cddl"), "a disallowed custom language must not be offered" ); } #[tokio::test] async fn test_completion_ignores_an_invalid_preferred_alias() { // A preferred alias the language does not have is a configuration error, so // completing to it would insert a label the linter rejects. let (server, uri, _dir) = server_with_md040_config("[MD040]\npreferred-aliases = { Shell = \"invalid_alias\" }\n").await; let items = server .get_language_completions(&uri, "invalid", 3, Position { line: 0, character: 10 }) .await; assert!( !items.iter().any(|item| item.label == "invalid_alias"), "an invalid alias must not be offered" ); // Control: a valid preference is offered as the label for its language. let (valid, valid_uri, _valid_dir) = server_with_md040_config("[MD040]\npreferred-aliases = { Shell = \"zsh\" }\n").await; let items = valid .get_language_completions(&valid_uri, "zsh", 3, Position { line: 0, character: 6 }) .await; assert!( items .iter() .any(|item| item.label == "zsh" && item.detail.as_deref() == Some("Shell (GitHub Linguist)")), "a valid preference is offered" ); } #[tokio::test] async fn test_completion_method_integration() { use std::fs; let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); let content = "# Hello\n\n```py\nprint('hi')\n```"; fs::write(&test_file, content).unwrap(); let server = create_test_server(); let uri = Url::from_file_path(&test_file).unwrap(); // Open the document server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Call completion method directly let params = CompletionParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, position: Position { line: 2, character: 5 }, // After ```py }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), context: None, }; let result = server.completion(params).await.unwrap(); assert!(result.is_some(), "Completion should return items"); if let Some(CompletionResponse::Array(items)) = result { assert!(!items.is_empty(), "Should have completion items"); // Check python is in the results let has_python = items.iter().any(|i| i.label.to_lowercase() == "python"); assert!(has_python, "Should include python as completion"); } else { panic!("Expected CompletionResponse::Array"); } } #[tokio::test] async fn test_completion_not_triggered_on_closing_fence() { use std::fs; let temp_dir = tempfile::tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); let content = "```python\nprint('hi')\n```"; fs::write(&test_file, content).unwrap(); let server = create_test_server(); let uri = Url::from_file_path(&test_file).unwrap(); // Open the document server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Call completion method on closing fence let params = CompletionParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, position: Position { line: 2, character: 3 }, // On closing ``` }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), context: None, }; let result = server.completion(params).await.unwrap(); assert!(result.is_none(), "Should NOT offer completion on closing fence"); } #[tokio::test] async fn test_completion_graceful_when_document_not_found() { let server = create_test_server(); // Use a URI for a document that doesn't exist and isn't opened let uri = Url::parse("file:///nonexistent/path/test.md").unwrap(); let params = CompletionParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri }, position: Position { line: 0, character: 3 }, }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), context: None, }; // Should return Ok(None), not an error let result = server.completion(params).await; assert!(result.is_ok(), "Completion should not error for missing document"); assert!(result.unwrap().is_none(), "Should return None for missing document"); } // ==================== Link Target Completion Tests ==================== #[test] fn test_detect_link_target_file_path_empty() { // Cursor right after `](` โ€” `](` is at columns 9-10, content starts at column 11 let text = "See [text]("; let pos = Position { line: 0, character: 11 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, ""); assert_eq!(info.path_start_col, 11); // UTF-16 column right after `(` assert!(info.anchor.is_none()); } #[test] fn test_detect_link_target_file_path_partial() { // Cursor mid-way through a file path // `](` is at columns 9-10; content_start = 11, so path_start_col = 11 let text = "See [text](docs/guide"; let pos = Position { line: 0, character: 21 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "docs/guide"); assert_eq!(info.path_start_col, 11); assert!(info.anchor.is_none()); } #[test] fn test_detect_link_target_anchor_empty() { // Cursor right after `#` let text = "See [text](guide.md#"; let pos = Position { line: 0, character: 20 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "guide.md"); assert!(info.anchor.is_some()); let (partial, start_col) = info.anchor.unwrap(); assert_eq!(partial, ""); assert_eq!(start_col, 20); // after `#` } #[test] fn test_detect_link_target_anchor_partial() { // Cursor mid-way through an anchor let text = "See [text](guide.md#install"; let pos = Position { line: 0, character: 27 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "guide.md"); let (partial, start_col) = info.anchor.unwrap(); assert_eq!(partial, "install"); assert_eq!(start_col, 20); } #[test] fn test_detect_link_target_anchor_same_file() { // Fragment-only link `[text](#anchor` โ€” empty file path let text = "[text](#sec"; let pos = Position { line: 0, character: 11 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, ""); let (partial, _start_col) = info.anchor.unwrap(); assert_eq!(partial, "sec"); } #[test] fn test_detect_link_target_closed_paren_no_completion() { // Cursor AFTER the closing `)` โ€” before_cursor includes `)`, so content // contains `)` and the function returns None. // "See [text](guide.md)" is 21 chars; `)` is at byte 20. // Cursor at 21 โ†’ before_cursor = whole string โ†’ content = "guide.md)" โ†’ None. let text = "See [text](guide.md) more"; let pos = Position { line: 0, character: 21 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_none(), "Should not complete after a closed link"); } #[test] fn test_detect_link_target_no_link_syntax() { // Regular text with no link let text = "Just plain text here"; let pos = Position { line: 0, character: 10 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_none()); } #[test] fn test_detect_link_target_code_span_skipped() { // `](` inside a code span โ€” should not trigger completion let text = "Use `[text](path` for links"; // cursor is after `path` (position 16), which is inside the code span let pos = Position { line: 0, character: 16 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_none(), "Should not complete inside a code span"); } #[test] fn test_detect_link_target_image_link() { // Image links `![alt](` should also trigger completion let text = "![image](imgs/"; let pos = Position { line: 0, character: 14 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); // `![image](` contains `](` so the backward scan will find it assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "imgs/"); } #[test] fn test_detect_link_target_multiple_links_on_line() { // Two links on the same line โ€” should detect the second one being typed let text = "[first](a.md) and [second](b.md"; let pos = Position { line: 0, character: 31 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "b.md"); } #[test] fn test_detect_link_target_non_ascii_link_text() { // "รฉ" is U+00E9: 2 UTF-8 bytes, 1 UTF-16 code unit. // "[rรฉsumรฉ](" is: `[` + r(1) + รฉ(1) + s(1) + u(1) + m(1) + รฉ(1) + `]` + `(` = 9 UTF-16 code units // So `](` spans columns 7-8, and content_start is column 9. let text = "[rรฉsumรฉ]("; let pos = Position { line: 0, character: 9 }; // right after `(` let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some(), "should detect link in non-ASCII context"); let info = result.unwrap(); assert_eq!(info.file_path, ""); // path_start_col must be the UTF-16 column after `(`, which is 9 assert_eq!(info.path_start_col, 9); assert!(info.anchor.is_none()); } #[test] fn test_detect_link_target_non_ascii_with_path() { // "[cafรฉ](docs/" โ€” "cafรฉ" = c(1)+a(1)+f(1)+รฉ(1) = 4 UTF-16 code units // "[cafรฉ](" spans columns 0-6; content_start is column 7 // cursor at 12 (7 + len("docs/") = 7+5 = 12) let text = "[cafรฉ](docs/"; let pos = Position { line: 0, character: 12 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "docs/"); assert_eq!(info.path_start_col, 7); // UTF-16 column after `(` } #[test] fn test_detect_link_target_out_of_bounds_position() { let text = "short"; let pos = Position { line: 0, character: 100, }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_none()); } #[test] fn test_detect_link_target_out_of_bounds_line() { let text = "single line"; let pos = Position { line: 5, character: 0 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_none()); } #[tokio::test] async fn test_get_file_completions_returns_workspace_files() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); // Create a few markdown files let current = root.join("current.md"); let other = root.join("other.md"); let sub_dir = root.join("docs"); fs::create_dir(&sub_dir).unwrap(); let sub_file = sub_dir.join("guide.md"); fs::write(¤t, "# Current").unwrap(); fs::write(&other, "# Other").unwrap(); fs::write(&sub_file, "# Guide").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); // Populate the workspace index manually { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); let mut fi = FileIndex::default(); fi.headings.push(HeadingIndex { text: "Current".to_string(), auto_anchor: "current".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(current.clone(), fi); let mut fi2 = FileIndex::default(); fi2.headings.push(HeadingIndex { text: "Other".to_string(), auto_anchor: "other".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(other.clone(), fi2); let mut fi3 = FileIndex::default(); fi3.headings.push(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(sub_file.clone(), fi3); } // Get all file completions (empty prefix) let items = server .get_file_completions(&uri, "", 10, Position { line: 0, character: 10 }) .await .items; // Should have 2 completions (other.md and docs/guide.md), NOT current.md assert_eq!(items.len(), 2, "Should return 2 files (excluding current)"); let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect(); assert!(labels.contains(&"other.md"), "Should include other.md"); assert!(labels.contains(&"docs/guide.md"), "Should include docs/guide.md"); assert!(!labels.contains(&"current.md"), "Should exclude current.md"); } #[tokio::test] async fn test_get_file_completions_filters_by_prefix() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let current = root.join("current.md"); let docs_dir = root.join("docs"); fs::create_dir(&docs_dir).unwrap(); let guide = docs_dir.join("guide.md"); let ref_doc = docs_dir.join("reference.md"); fs::write(¤t, "").unwrap(); fs::write(&guide, "").unwrap(); fs::write(&ref_doc, "").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); index.insert_file(guide.clone(), FileIndex::default()); index.insert_file(ref_doc.clone(), FileIndex::default()); } // Filter by "docs/g" prefix let items = server .get_file_completions(&uri, "docs/g", 10, Position { line: 0, character: 16 }) .await .items; assert_eq!(items.len(), 1, "Should return only docs/guide.md"); assert_eq!(items[0].label, "docs/guide.md"); } #[tokio::test] async fn test_get_file_completions_ranks_nearer_files_first() { use crate::workspace_index::{FileIndex, WorkspaceIndex}; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); // current file is deep in the tree; a sibling is distance 0, a file at the // root is distance 2 (../../). The nearer file must come first. let current = temp_dir.path().join("a/b/current.md"); let sibling = temp_dir.path().join("a/b/sibling.md"); let faraway = temp_dir.path().join("faraway.md"); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); index.insert_file(sibling.clone(), FileIndex::default()); index.insert_file(faraway.clone(), FileIndex::default()); } let items = server .get_file_completions(&uri, "", 10, Position { line: 0, character: 10 }) .await .items; assert_eq!(items.len(), 2); assert_eq!(items[0].label, "sibling.md", "nearest file ranks first"); assert_eq!(items[1].label, "../../faraway.md", "distant file ranks last"); // Sort keys must also encode the distance so the editor preserves the order. let sibling_sort = items[0].sort_text.as_deref().unwrap(); let faraway_sort = items[1].sort_text.as_deref().unwrap(); assert!( sibling_sort < faraway_sort, "nearer file must sort before farther file ({sibling_sort:?} vs {faraway_sort:?})" ); assert!( sibling_sort.starts_with("0000"), "distance-0 file sort key: {sibling_sort:?}" ); assert!( faraway_sort.starts_with("0002"), "distance-2 file sort key: {faraway_sort:?}" ); } #[tokio::test] async fn test_get_file_completions_marks_incomplete_when_capped() { use crate::workspace_index::{FileIndex, WorkspaceIndex}; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let current = temp_dir.path().join("current.md"); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); // 60 candidate files exceeds the 50-item cap. for i in 0..60 { index.insert_file(temp_dir.path().join(format!("file{i:03}.md")), FileIndex::default()); } } let list = server .get_file_completions(&uri, "", 10, Position { line: 0, character: 10 }) .await; assert_eq!(list.items.len(), 50, "result set is capped at 50"); assert!( list.is_incomplete, "capped result must be marked incomplete so the editor re-queries as the prefix narrows" ); } #[tokio::test] async fn test_get_file_completions_complete_when_not_capped() { use crate::workspace_index::{FileIndex, WorkspaceIndex}; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let current = root.join("current.md"); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); index.insert_file(root.join("other.md"), FileIndex::default()); } let list = server .get_file_completions(&uri, "", 10, Position { line: 0, character: 10 }) .await; assert_eq!(list.items.len(), 1); assert!(!list.is_incomplete, "small result set is complete"); } #[tokio::test] async fn test_get_file_completions_absolute_lists_content_root() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let img_dir = temp_dir.path().join("img"); fs::create_dir(&img_dir).unwrap(); fs::write(img_dir.join("01.webp"), "").unwrap(); fs::write(img_dir.join("02.png"), "").unwrap(); fs::create_dir(img_dir.join("icons")).unwrap(); let current = temp_dir.path().join("doc.md"); fs::write(¤t, "").unwrap(); let server = create_test_server(); // No explicit content roots: the workspace root is used. *server.workspace_roots.write().await = vec![temp_dir.path().to_path_buf()]; let uri = Url::from_file_path(¤t).unwrap(); // `/img/` lists immediate children of the content root's img directory, // including non-markdown files and subdirectories. let list = server .get_file_completions(&uri, "/img/", 10, Position { line: 0, character: 15 }) .await; assert!( list.is_incomplete, "absolute completion is always incomplete (drill-in)" ); let labels: Vec<&str> = list.items.iter().map(|i| i.label.as_str()).collect(); assert!(labels.contains(&"01.webp"), "non-markdown asset offered: {labels:?}"); assert!(labels.contains(&"02.png"), "non-markdown asset offered: {labels:?}"); assert!( labels.contains(&"icons/"), "subdirectory offered with trailing slash: {labels:?}" ); // The inserted text is the full absolute path from the leading slash. let webp = list.items.iter().find(|i| i.label == "01.webp").unwrap(); let new_text = match webp.text_edit.as_ref().unwrap() { tower_lsp::lsp_types::CompletionTextEdit::Edit(e) => &e.new_text, tower_lsp::lsp_types::CompletionTextEdit::InsertAndReplace(_) => panic!("expected a plain text edit"), }; assert_eq!(new_text, "/img/01.webp"); // filterText must be the full replacement text so clients that filter against // the replaced range (`/img/01...`) keep the item visible. assert_eq!( webp.filter_text.as_deref(), Some("/img/01.webp"), "filterText should be the full path, not just the child name" ); } #[tokio::test] async fn test_get_file_completions_absolute_filters_by_prefix() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let img_dir = temp_dir.path().join("img"); fs::create_dir(&img_dir).unwrap(); fs::write(img_dir.join("01.webp"), "").unwrap(); fs::write(img_dir.join("readme.md"), "").unwrap(); let current = temp_dir.path().join("doc.md"); fs::write(¤t, "").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![temp_dir.path().to_path_buf()]; let uri = Url::from_file_path(¤t).unwrap(); let list = server .get_file_completions(&uri, "/img/0", 10, Position { line: 0, character: 16 }) .await; let labels: Vec<&str> = list.items.iter().map(|i| i.label.as_str()).collect(); assert_eq!( labels, vec!["01.webp"], "only entries matching the prefix '0': {labels:?}" ); } #[tokio::test] async fn test_get_file_completions_absolute_without_content_root_is_empty() { use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let current = temp_dir.path().join("doc.md"); let server = create_test_server(); // No workspace roots and no configured content roots. let uri = Url::from_file_path(¤t).unwrap(); let list = server .get_file_completions(&uri, "/img/", 10, Position { line: 0, character: 15 }) .await; assert!(list.items.is_empty(), "no content root means no absolute completions"); } #[tokio::test] async fn test_get_file_completions_absolute_rejects_parent_traversal() { use std::fs; use tempfile::tempdir; // A secret directory that sits next to the content root but outside it. let temp_dir = tempdir().unwrap(); let root = temp_dir.path().join("site"); fs::create_dir(&root).unwrap(); let secret = temp_dir.path().join("secret"); fs::create_dir(&secret).unwrap(); fs::write(secret.join("private.txt"), "").unwrap(); let current = root.join("doc.md"); fs::write(¤t, "").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; let uri = Url::from_file_path(¤t).unwrap(); // `..` would escape the content root; completion must refuse rather than // list files from the parent directory. let list = server .get_file_completions(&uri, "/../secret/", 10, Position { line: 0, character: 20 }) .await; assert!( list.items.is_empty(), "parent traversal must not surface files outside the content root: {:?}", list.items.iter().map(|i| &i.label).collect::>() ); } #[tokio::test] async fn test_get_anchor_completions_returns_headings() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let current = root.join("index.md"); let target = root.join("guide.md"); fs::write(¤t, "").unwrap(); fs::write(&target, "# Installation\n\n## Configuration\n\n## Troubleshooting").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); let mut fi = FileIndex::default(); fi.headings = vec![ HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }, HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }, HeadingIndex { text: "Troubleshooting".to_string(), auto_anchor: "troubleshooting".to_string(), custom_anchor: None, line: 5, text_lines: 1, is_setext: false, }, ]; index.insert_file(target.clone(), fi); } // Completions for all anchors in guide.md (empty prefix) let items = server .get_anchor_completions(&uri, "guide.md", "", 27, Position { line: 0, character: 27 }) .await; assert_eq!(items.len(), 3, "Should return all 3 headings"); // Items should be in document order (sorted by line number) assert_eq!(items[0].insert_text.as_deref(), Some("installation")); assert_eq!(items[1].insert_text.as_deref(), Some("configuration")); assert_eq!(items[2].insert_text.as_deref(), Some("troubleshooting")); } #[tokio::test] async fn test_get_anchor_completions_resolves_absolute_path_against_content_root() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let current = temp_dir.path().join("index.md"); let target = temp_dir.path().join("guide.md"); fs::write(¤t, "").unwrap(); fs::write(&target, "# Installation").unwrap(); let server = create_test_server(); // The content root is the workspace root, so `/guide.md` maps to it. *server.workspace_roots.write().await = vec![temp_dir.path().to_path_buf()]; let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); let mut fi = FileIndex::default(); fi.headings = vec![HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }]; index.insert_file(target.clone(), fi); } // An absolute-style link `](/guide.md#` must resolve against the content // root, not the OS filesystem root. let items = server .get_anchor_completions(&uri, "/guide.md", "", 27, Position { line: 0, character: 27 }) .await; assert_eq!( items.iter().map(|i| i.insert_text.as_deref()).collect::>(), vec![Some("installation")], "absolute anchor target should resolve under the content root" ); } #[tokio::test] async fn test_get_anchor_completions_absolute_falls_back_to_disk_outside_workspace() { use std::fs; use tempfile::tempdir; // The content root lives outside the indexed workspace, so its files are // never added to the workspace index. Anchor completion must still work by // reading the target from disk, matching the file-path completion behavior. let temp_dir = tempdir().unwrap(); let workspace = temp_dir.path().join("workspace"); let content_root = temp_dir.path().join("site"); fs::create_dir(&workspace).unwrap(); fs::create_dir(&content_root).unwrap(); let current = workspace.join("index.md"); let target = content_root.join("guide.md"); fs::write(¤t, "").unwrap(); fs::write(&target, "# Installation\n\n## Configuration\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![workspace.clone()]; server.config.write().await.link_completion_content_roots = vec![content_root.to_string_lossy().into_owned()]; let uri = Url::from_file_path(¤t).unwrap(); // Only the current file is indexed; the content root is not. { use crate::workspace_index::{FileIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); } let items = server .get_anchor_completions(&uri, "/guide.md", "", 27, Position { line: 0, character: 27 }) .await; assert_eq!( items.iter().map(|i| i.insert_text.as_deref()).collect::>(), vec![Some("installation"), Some("configuration")], "absolute anchor target outside the workspace should resolve via on-disk fallback" ); } /// A target parsed from disk generates its anchors from its own configuration. /// /// The workspace index already interprets each document in its own scope, so a /// fallback reading the root config would offer an anchor that navigation into /// the same file then fails to find. The two anchor styles differ only in how /// they treat the punctuation, which is what makes the offered value decide /// which config spoke. #[tokio::test] async fn test_get_anchor_completions_disk_fallback_uses_the_target_scope() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let workspace = base.join("workspace"); let content_root = base.join("site"); let user_config_dir = base.join("userconfig"); let home_dir = base.join("fakehome"); fs::create_dir_all(&workspace).unwrap(); fs::create_dir_all(&content_root).unwrap(); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( workspace.join(".rumdl.toml"), "[global]\nflavor = \"standard\"\n\n[MD051]\nanchor-style = \"python-markdown\"\n", ) .unwrap(); fs::write( content_root.join(".rumdl.toml"), "[global]\nflavor = \"standard\"\n\n[MD051]\nanchor-style = \"github\"\n", ) .unwrap(); let current = workspace.join("index.md"); let target = content_root.join("guide.md"); fs::write(¤t, "").unwrap(); fs::write(&target, "# Getting Started โ€” Advanced\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![workspace.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; server.config.write().await.link_completion_content_roots = vec![content_root.to_string_lossy().into_owned()]; let uri = Url::from_file_path(¤t).unwrap(); // Only the current file is indexed, so the target is read from disk. { use crate::workspace_index::{FileIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); } let items = server .get_anchor_completions(&uri, "/guide.md", "", 27, Position { line: 0, character: 27 }) .await; assert_eq!( items.iter().map(|i| i.insert_text.as_deref()).collect::>(), vec![Some("getting-started--advanced")], "the anchor style of the target's own config must decide what is offered" ); } #[tokio::test] async fn test_get_anchor_completions_absolute_rejects_parent_traversal() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().join("site"); fs::create_dir(&root).unwrap(); let current = root.join("index.md"); // A secret file outside the content root but inside the indexed workspace. let secret = temp_dir.path().join("secret.md"); fs::write(¤t, "").unwrap(); fs::write(&secret, "# Secret").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); let mut fi = FileIndex::default(); fi.headings = vec![HeadingIndex { text: "Secret".to_string(), auto_anchor: "secret".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }]; index.insert_file(secret.clone(), fi); } // `/../secret.md#` would escape the content root; anchors must not leak. let items = server .get_anchor_completions(&uri, "/../secret.md", "", 27, Position { line: 0, character: 27 }) .await; assert!( items.is_empty(), "parent traversal must not expose anchors outside the content root: {:?}", items.iter().map(|i| &i.label).collect::>() ); } #[tokio::test] async fn test_get_anchor_completions_filters_by_prefix() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let current = root.join("index.md"); let target = root.join("guide.md"); fs::write(¤t, "").unwrap(); fs::write(&target, "").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); let mut fi = FileIndex::default(); fi.headings = vec![ HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }, HeadingIndex { text: "Introduction".to_string(), auto_anchor: "introduction".to_string(), custom_anchor: None, line: 2, text_lines: 1, is_setext: false, }, HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }, ]; index.insert_file(target.clone(), fi); } let items = server .get_anchor_completions(&uri, "guide.md", "in", 27, Position { line: 0, character: 27 }) .await; assert_eq!(items.len(), 2, "Should return installation and introduction"); let labels: Vec<&str> = items.iter().map(|i| i.label.as_str()).collect(); assert!(labels.contains(&"Installation")); assert!(labels.contains(&"Introduction")); } #[tokio::test] async fn test_get_anchor_completions_uses_custom_anchor() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let current = root.join("index.md"); let target = root.join("guide.md"); fs::write(¤t, "").unwrap(); fs::write(&target, "").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(current.clone(), FileIndex::default()); let mut fi = FileIndex::default(); fi.headings = vec![HeadingIndex { text: "Getting Started".to_string(), auto_anchor: "getting-started".to_string(), custom_anchor: Some("start".to_string()), line: 1, text_lines: 1, is_setext: false, }]; index.insert_file(target.clone(), fi); } let items = server .get_anchor_completions(&uri, "guide.md", "", 10, Position { line: 0, character: 10 }) .await; assert_eq!(items.len(), 1); // Should use custom_anchor "start", not auto_anchor "getting-started" assert_eq!(items[0].insert_text.as_deref(), Some("start")); assert_eq!(items[0].label, "Getting Started"); assert_eq!(items[0].detail.as_deref(), Some("#start")); } #[tokio::test] async fn test_get_anchor_completions_empty_file_path_uses_current() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let current = root.join("page.md"); fs::write(¤t, "# Section One\n\n# Section Two").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); let mut fi = FileIndex::default(); fi.headings = vec![ HeadingIndex { text: "Section One".to_string(), auto_anchor: "section-one".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }, HeadingIndex { text: "Section Two".to_string(), auto_anchor: "section-two".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }, ]; index.insert_file(current.clone(), fi); } // Empty file_path means "anchor in the current file" let items = server .get_anchor_completions(&uri, "", "", 8, Position { line: 0, character: 8 }) .await; assert_eq!(items.len(), 2); let insert_texts: Vec<&str> = items.iter().map(|i| i.insert_text.as_deref().unwrap_or("")).collect(); assert!(insert_texts.contains(&"section-one")); assert!(insert_texts.contains(&"section-two")); } #[tokio::test] async fn test_get_anchor_completions_unknown_file_returns_empty() { let temp_dir = tempfile::tempdir().unwrap(); let current = temp_dir.path().join("index.md"); std::fs::write(¤t, "").unwrap(); let server = create_test_server(); let uri = Url::from_file_path(¤t).unwrap(); // Don't populate the workspace index โ€” file not found should return empty let items = server .get_anchor_completions(&uri, "nonexistent.md", "", 10, Position { line: 0, character: 10 }) .await; assert!(items.is_empty(), "Unknown file should return no completions"); } #[test] fn test_detect_link_target_relative_parent_path() { // Cursor inside a `../` relative path let text = "See [link](../other/file"; let pos = Position { line: 0, character: 24 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "../other/file"); assert!(info.anchor.is_none()); } #[test] fn test_detect_link_target_path_and_anchor() { // Full path with anchor: `](../dir/file.md#section` let text = "See [link](../dir/file.md#section"; let pos = Position { line: 0, character: 33 }; let result = RumdlLanguageServer::detect_link_target_position(text, pos); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.file_path, "../dir/file.md"); let (partial, _) = info.anchor.unwrap(); assert_eq!(partial, "section"); } #[tokio::test] async fn test_link_completions_disabled_returns_none() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); let content = "See [text]("; fs::write(&test_file, content).unwrap(); let server = create_test_server(); // Disable link completions server.config.write().await.enable_link_completions = false; let uri = Url::from_file_path(&test_file).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let params = CompletionParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri }, position: Position { line: 0, character: 11 }, }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), context: None, }; let result = server.completion(params).await.unwrap(); assert!(result.is_none(), "Link completions should be suppressed when disabled"); } #[tokio::test] async fn test_code_fence_completion_works_when_link_completions_disabled() { use std::fs; use tempfile::tempdir; // Disabling link completions must NOT disable fenced code-block language // completion - they share one completion capability but are independent. let temp_dir = tempdir().unwrap(); let test_file = temp_dir.path().join("test.md"); let content = "# Hello\n\n```py\nprint('hi')\n```"; fs::write(&test_file, content).unwrap(); let server = create_test_server(); server.config.write().await.enable_link_completions = false; let uri = Url::from_file_path(&test_file).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let params = CompletionParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri }, position: Position { line: 2, character: 5 }, // After ```py }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), context: None, }; let result = server.completion(params).await.unwrap(); let Some(CompletionResponse::Array(items)) = result else { panic!("code-fence completion should still return items when link completions are off"); }; assert!( items.iter().any(|i| i.label.to_lowercase() == "python"), "python language completion must still work with link completions disabled" ); } #[tokio::test] async fn test_link_navigation_disabled_hover_returns_none() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///tmp/test.md").unwrap(), }, position: Position { line: 0, character: 5 }, }, work_done_progress_params: WorkDoneProgressParams::default(), }; let result = server.hover(params).await.unwrap(); assert!( result.is_none(), "Hover should be suppressed when link navigation is disabled" ); } #[tokio::test] async fn test_link_navigation_disabled_goto_definition_returns_none() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = GotoDefinitionParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///tmp/test.md").unwrap(), }, position: Position { line: 0, character: 5 }, }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; let result = server.goto_definition(params).await.unwrap(); assert!( result.is_none(), "Go-to-definition should be suppressed when link navigation is disabled" ); } #[tokio::test] async fn test_link_navigation_disabled_references_returns_none() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = ReferenceParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///tmp/test.md").unwrap(), }, position: Position { line: 0, character: 5 }, }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), context: ReferenceContext { include_declaration: false, }, }; let result = server.references(params).await.unwrap(); assert!( result.is_none(), "References should be suppressed when link navigation is disabled" ); } #[tokio::test] async fn test_link_navigation_disabled_prepare_rename_returns_none() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///tmp/test.md").unwrap(), }, position: Position { line: 0, character: 5 }, }; let result = server.prepare_rename(params).await.unwrap(); assert!( result.is_none(), "Prepare-rename should be suppressed when link navigation is disabled" ); } #[tokio::test] async fn test_link_navigation_disabled_rename_returns_none() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = RenameParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///tmp/test.md").unwrap(), }, position: Position { line: 0, character: 5 }, }, new_name: "new-heading".to_string(), work_done_progress_params: WorkDoneProgressParams::default(), }; let result = server.rename(params).await.unwrap(); assert!( result.is_none(), "Rename should be suppressed when link navigation is disabled" ); } #[tokio::test] async fn test_link_navigation_disabled_via_did_change_configuration() { let server = create_test_server(); // Default state: navigation is enabled assert!(server.config.read().await.enable_link_navigation); // Simulate a live config update with only enableLinkNavigation: false server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "enableLinkNavigation": false }), }) .await; // Flag must be applied โ€” this is what the did_change_configuration heuristic guards assert!( !server.config.read().await.enable_link_navigation, "did_change_configuration must apply enableLinkNavigation: false" ); // Confirm the handler respects the updated flag let result = server .hover(HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///tmp/test.md").unwrap(), }, position: Position { line: 0, character: 5 }, }, work_done_progress_params: WorkDoneProgressParams::default(), }) .await .unwrap(); assert!( result.is_none(), "Hover should be suppressed after live config disables link navigation" ); } #[tokio::test] async fn test_content_roots_applied_via_did_change_configuration() { let server = create_test_server(); // Default state: no configured content roots. assert!(server.config.read().await.link_completion_content_roots.is_empty()); // A settings payload that only sets linkCompletionContentRoots must still be // recognized as a full config and applied (not dropped as an unknown key). server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "linkCompletionContentRoots": ["/site", "docs"] }), }) .await; assert_eq!( server.config.read().await.link_completion_content_roots, vec!["/site".to_string(), "docs".to_string()], "did_change_configuration must apply linkCompletionContentRoots on its own" ); // Clearing the list back to [] must also apply, resetting to the // workspace-root default rather than leaving the previous roots active. server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "linkCompletionContentRoots": [] }), }) .await; assert!( server.config.read().await.link_completion_content_roots.is_empty(), "did_change_configuration must apply an empty linkCompletionContentRoots" ); } #[tokio::test] async fn test_did_change_configuration_applies_a_setting_set_back_to_its_default() { let server = create_test_server(); for (key, off, on) in [ ("enableAutoFix", true, false), ("enableLinting", false, true), ("enableLinkCompletions", false, true), ("enableLinkNavigation", false, true), ("enableSymbols", false, true), ] { for value in [off, on] { server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ key: value }), }) .await; let config = serde_json::to_value(&*server.config.read().await).unwrap(); assert_eq!(config[key], value, "{{\"{key}\": {value}}} must apply"); } } // The same holds for the Neovim-style payload nested under "rumdl". for value in [true, false] { server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "rumdl": { "enableAutoFix": value } }), }) .await; assert_eq!(server.config.read().await.enable_auto_fix, value); } } #[tokio::test] async fn test_did_change_configuration_keeps_rule_settings_across_unrelated_updates() { let server = create_test_server(); server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "disable": ["MD009"] }), }) .await; let disabled = || async { server .config .read() .await .settings .as_ref() .and_then(|s| s.disable.clone()) }; assert_eq!(disabled().await, Some(vec!["MD009".to_string()])); // Neither a flag set to its default nor a payload with no key rumdl knows // replaces the rule settings. for settings in [ serde_json::json!({ "enableAutoFix": false }), serde_json::json!({ "configurationPreference": "editorFirst" }), serde_json::json!({ "someOtherExtensionKey": 1 }), serde_json::json!({}), ] { server .did_change_configuration(DidChangeConfigurationParams { settings: settings.clone(), }) .await; assert_eq!( disabled().await, Some(vec!["MD009".to_string()]), "{settings} must not reset the rule settings" ); } } #[test] fn test_link_navigation_config_serde_roundtrip() { // Verify `enableLinkNavigation: false` round-trips correctly through serde let json = r#"{"enableLinkNavigation": false}"#; let config: RumdlLspConfig = serde_json::from_str(json).unwrap(); assert!( !config.enable_link_navigation, "enableLinkNavigation should deserialize to false" ); // All other fields should use their defaults assert!(config.enable_linting, "enableLinting should default to true"); assert!( config.enable_link_completions, "enableLinkCompletions should default to true" ); // Verify serialization produces camelCase key let serialized = serde_json::to_string(&config).unwrap(); assert!(serialized.contains("\"enableLinkNavigation\":false")); } /// Test that MD013 semantic-line-breaks config produces no false positives with CRLF line endings. /// The LSP receives content from the editor which may use CRLF line endings on Windows. /// The reflow comparison must account for line ending differences. /// Regression test for issue #459. #[tokio::test] async fn test_lsp_md013_semantic_line_breaks_crlf() { use tempfile::tempdir; let server = create_test_server(); // Create a temp directory with pyproject.toml let temp_dir = tempdir().expect("Failed to create temp dir"); let pyproject_path = temp_dir.path().join("pyproject.toml"); std::fs::write( &pyproject_path, r#" [tool.rumdl.MD013] line-length = 80 reflow = true reflow-mode = "semantic-line-breaks" "#, ) .expect("Failed to write pyproject.toml"); // Create a test markdown file with CRLF line endings let test_md_path = temp_dir.path().join("test.md"); // This content is properly formatted for semantic line breaks // but uses CRLF line endings (as sent by editors on Windows) let content_crlf = "# Title\r\n\r\nLorem ipsum dolor sit amet, consectetur adipiscing elit.\r\nNullam vehicula commodo lobortis.\r\nDonec a venenatis lorem.\r\n"; std::fs::write(&test_md_path, content_crlf).expect("Failed to write test.md"); let canonical_test_path = test_md_path.resolve_like_server(); // Add workspace root let canonical_temp = temp_dir.path().resolve_like_server(); server.workspace_roots.write().await.push(canonical_temp); // Lint via LSP path with CRLF content let uri = Url::from_file_path(&canonical_test_path).unwrap(); let diagnostics = server.lint_document(&uri, content_crlf, true).await.unwrap(); // Filter for MD013 diagnostics let md013_diagnostics: Vec<_> = diagnostics .iter() .filter(|d| { d.code .as_ref() .is_some_and(|c| matches!(c, NumberOrString::String(s) if s == "MD013")) }) .collect(); assert!( md013_diagnostics.is_empty(), "LSP should produce no MD013 warnings for properly formatted semantic-line-break content \ with CRLF line endings, but found {} warnings: {:?}", md013_diagnostics.len(), md013_diagnostics .iter() .map(|d| format!("line {}: {}", d.range.start.line, d.message)) .collect::>() ); } /// Test that MD013 still emits warnings for improperly formatted CRLF content. /// The fix for issue #459 must not suppress legitimate warnings. #[tokio::test] async fn test_lsp_md013_semantic_line_breaks_crlf_still_warns_when_needed() { use tempfile::tempdir; let server = create_test_server(); let temp_dir = tempdir().expect("Failed to create temp dir"); let pyproject_path = temp_dir.path().join("pyproject.toml"); std::fs::write( &pyproject_path, r#" [tool.rumdl.MD013] line-length = 80 reflow = true reflow-mode = "semantic-line-breaks" "#, ) .expect("Failed to write pyproject.toml"); let test_md_path = temp_dir.path().join("test.md"); // Content with multiple sentences on one line (needs reflow) using CRLF let content_crlf = "# Title\r\n\r\nLorem ipsum dolor sit amet. Consectetur adipiscing elit. Nullam vehicula commodo lobortis.\r\n"; std::fs::write(&test_md_path, content_crlf).expect("Failed to write test.md"); let canonical_test_path = test_md_path.resolve_like_server(); let canonical_temp = temp_dir.path().resolve_like_server(); server.workspace_roots.write().await.push(canonical_temp); let uri = Url::from_file_path(&canonical_test_path).unwrap(); let diagnostics = server.lint_document(&uri, content_crlf, true).await.unwrap(); let md013_diagnostics: Vec<_> = diagnostics .iter() .filter(|d| { d.code .as_ref() .is_some_and(|c| matches!(c, NumberOrString::String(s) if s == "MD013")) }) .collect(); assert!( !md013_diagnostics.is_empty(), "LSP should produce MD013 warnings for improperly formatted semantic-line-break CRLF content" ); } /// Test that MD013 semantic-line-breaks config from pyproject.toml is respected in LSP /// This verifies that the LSP and CLI produce the same results for the same config. /// Regression test for issue #459. #[tokio::test] async fn test_lsp_md013_semantic_line_breaks_config_parity() { use tempfile::tempdir; let server = create_test_server(); // Create a temp directory with pyproject.toml let temp_dir = tempdir().expect("Failed to create temp dir"); let pyproject_path = temp_dir.path().join("pyproject.toml"); std::fs::write( &pyproject_path, r#" [tool.rumdl.MD013] line-length = 80 reflow = true reflow-mode = "semantic-line-breaks" "#, ) .expect("Failed to write pyproject.toml"); // Create a test markdown file in the same directory let test_md_path = temp_dir.path().join("test.md"); let content = "# Title\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit.\nNullam vehicula commodo lobortis.\nDonec a venenatis lorem.\n"; std::fs::write(&test_md_path, content).expect("Failed to write test.md"); let uri = Url::from_file_path(&test_md_path).unwrap(); // Load the pyproject.toml the way resolve_config_for_file loads a config it // discovered, so this exercises the production loader rather than a lookalike. let sourced = crate::config::SourcedConfig::load_discovered(&pyproject_path, None, None).expect("Should load config"); let file_config: crate::config::Config = sourced.into_validated_unchecked().into(); // Verify the config loaded correctly let md013_rule_config = file_config.rules.get("MD013"); assert!( md013_rule_config.is_some(), "MD013 config should be present in loaded config" ); let md013_values = &md013_rule_config.unwrap().values; assert!( md013_values.get("reflow-mode").is_some() || md013_values.get("reflow_mode").is_some(), "reflow-mode should be in MD013 config values, got: {:?}", md013_values.keys().collect::>() ); // Set the config on the server *server.rumdl_config.write().await = file_config; // Lint via LSP path let diagnostics = server.lint_document(&uri, content, true).await.unwrap(); // Filter for MD013 diagnostics let md013_diagnostics: Vec<_> = diagnostics .iter() .filter(|d| { d.code .as_ref() .is_some_and(|c| matches!(c, NumberOrString::String(s) if s == "MD013")) }) .collect(); assert!( md013_diagnostics.is_empty(), "LSP should produce no MD013 warnings for properly formatted semantic-line-break content, \ but found {} warnings: {:?}", md013_diagnostics.len(), md013_diagnostics .iter() .map(|d| format!("line {}: {}", d.range.start.line, d.message)) .collect::>() ); // Also verify CLI path produces same result let config_path_str2 = pyproject_path.to_str().unwrap(); let sourced2 = crate::config::SourcedConfig::load_with_discovery(Some(config_path_str2), None, false) .expect("Should load config"); let cli_config: crate::config::Config = sourced2.into_validated_unchecked().into(); let all_rules = crate::rules::all_rules(&cli_config); let filtered_rules = crate::rules::filter_rules(&all_rules, &cli_config.global); let cli_warnings = crate::lint( content, &filtered_rules, false, crate::config::MarkdownFlavor::Standard, None, Some(&cli_config), ) .expect("CLI lint should succeed"); let cli_md013: Vec<_> = cli_warnings .iter() .filter(|w| w.rule_name.as_deref() == Some("MD013")) .collect(); assert!(cli_md013.is_empty(), "CLI should produce no MD013 warnings either"); } /// Test that MD013 semantic-line-breaks config works through the full resolve_config_for_file path. /// This tests the actual file discovery path the LSP uses, which is different from directly setting config. /// Regression test for issue #459. #[tokio::test] async fn test_lsp_md013_resolve_config_for_file_path() { use tempfile::tempdir; let server = create_test_server(); // Create a temp directory with pyproject.toml let temp_dir = tempdir().expect("Failed to create temp dir"); let pyproject_path = temp_dir.path().join("pyproject.toml"); std::fs::write( &pyproject_path, r#" [tool.rumdl] [tool.rumdl.MD013] line-length = 80 reflow = true reflow-mode = "semantic-line-breaks" "#, ) .expect("Failed to write pyproject.toml"); // Create a test markdown file in the same directory let test_md_path = temp_dir.path().join("test.md"); let content = "# Title\n\nLorem ipsum dolor sit amet, consectetur adipiscing elit.\nNullam vehicula commodo lobortis.\nDonec a venenatis lorem.\n"; std::fs::write(&test_md_path, content).expect("Failed to write test.md"); // Add the temp dir as a workspace root (otherwise resolve_config_for_file walks up forever) let canonical_temp = temp_dir.path().resolve_like_server(); server.workspace_roots.write().await.push(canonical_temp.clone()); // Use the real resolve_config_for_file path let canonical_test_path = test_md_path.resolve_like_server(); let resolved_config = server.resolve_config_for_file(&canonical_test_path).await; // Verify the config loaded correctly let md013_rule_config = resolved_config.rules.get("MD013"); assert!( md013_rule_config.is_some(), "MD013 config should be present after resolve_config_for_file. Rules: {:?}", resolved_config.rules.keys().collect::>() ); let md013_values = &md013_rule_config.unwrap().values; let has_reflow_mode = md013_values.get("reflow-mode").is_some() || md013_values.get("reflow_mode").is_some(); assert!( has_reflow_mode, "reflow-mode should be in MD013 config values after resolve_config_for_file, got: {:?}", md013_values.keys().collect::>() ); let has_reflow = md013_values.get("reflow").is_some(); assert!( has_reflow, "reflow should be in MD013 config values after resolve_config_for_file, got: {:?}", md013_values.keys().collect::>() ); // Now create rules from this config and check linting result let all_rules = crate::rules::all_rules(&resolved_config); let filtered_rules = crate::rules::filter_rules(&all_rules, &resolved_config.global); let warnings = crate::lint( content, &filtered_rules, false, crate::config::MarkdownFlavor::Standard, None, Some(&resolved_config), ) .expect("Lint should succeed"); let md013_warnings: Vec<_> = warnings .iter() .filter(|w| w.rule_name.as_deref() == Some("MD013")) .collect(); assert!( md013_warnings.is_empty(), "Should produce no MD013 warnings for semantic-line-break content via resolve_config_for_file path, \ but found {} warnings: {:?}", md013_warnings.len(), md013_warnings .iter() .map(|w| format!("line {}: {} - {}", w.line, w.message, w.message)) .collect::>() ); // Also test the full lint_document path let uri = Url::from_file_path(&canonical_test_path).unwrap(); let diagnostics = server.lint_document(&uri, content, true).await.unwrap(); let md013_diags: Vec<_> = diagnostics .iter() .filter(|d| { d.code .as_ref() .is_some_and(|c| matches!(c, NumberOrString::String(s) if s == "MD013")) }) .collect(); assert!( md013_diags.is_empty(), "lint_document should produce no MD013 diagnostics for semantic-line-break content, \ but found {} diagnostics: {:?}", md013_diags.len(), md013_diags .iter() .map(|d| format!("line {}: {}", d.range.start.line, d.message)) .collect::>() ); } /// Test that MD007 indent=4 config is respected through the full LSP formatting path. /// Verifies that [ul-indent] alias, indent=4, and style="fixed" all propagate correctly /// from config file through resolve_config_for_file to the formatted output. #[tokio::test] async fn test_lsp_md007_formatting_respects_indent_config() { use tempfile::tempdir; let server = create_test_server(); // Create a temp directory with .rumdl.toml using [ul-indent] alias let temp_dir = tempdir().expect("Failed to create temp dir"); let config_path = temp_dir.path().join(".rumdl.toml"); std::fs::write( &config_path, r#" [ul-indent] indent = 4 style = "fixed" "#, ) .expect("Failed to write .rumdl.toml"); // Create test markdown with 2-space indentation (should be fixed to 4-space) let test_md_path = temp_dir.path().join("test.md"); let content = "# Test\n\n- Bullet item\n - Nested bullet\n"; std::fs::write(&test_md_path, content).expect("Failed to write test.md"); // Set up workspace root let canonical_temp = temp_dir.path().resolve_like_server(); server.workspace_roots.write().await.push(canonical_temp.clone()); // Step 1: Verify config is loaded correctly let canonical_test_path = test_md_path.resolve_like_server(); let resolved_config = server.resolve_config_for_file(&canonical_test_path).await; let md007_config = resolved_config.rules.get("MD007"); assert!( md007_config.is_some(), "MD007 config should be present. Rules: {:?}", resolved_config.rules.keys().collect::>() ); let md007_values = &md007_config.unwrap().values; let indent_value = md007_values.get("indent").map(|v| v.as_integer().unwrap_or(0)); assert_eq!(indent_value, Some(4), "MD007 indent should be 4, got: {md007_values:?}"); // Step 2: Verify detection works (should find 2-space indent as violation) let all_rules = crate::rules::all_rules(&resolved_config); let filtered_rules = crate::rules::filter_rules(&all_rules, &resolved_config.global); let warnings = crate::lint( content, &filtered_rules, false, crate::config::MarkdownFlavor::Standard, None, Some(&resolved_config), ) .expect("Lint should succeed"); let md007_warnings: Vec<_> = warnings .iter() .filter(|w| w.rule_name.as_deref() == Some("MD007")) .collect(); assert_eq!( md007_warnings.len(), 1, "Should find exactly 1 MD007 warning for 2-space indent, found: {:?}", md007_warnings.iter().map(|w| &w.message).collect::>() ); assert!( md007_warnings[0].message.contains("Expected 4 spaces"), "Warning should mention 4 spaces, got: {}", md007_warnings[0].message ); // Step 3: Verify the fix produces 4-space indent (not 2-space!) assert!(md007_warnings[0].fix.is_some(), "MD007 warning should have a fix"); let fix = md007_warnings[0].fix.as_ref().unwrap(); assert_eq!( fix.replacement, " ", "Fix replacement should be 4 spaces, got: {:?}", fix.replacement ); // Step 4: Exercise the full LSP formatting path let uri = Url::from_file_path(&canonical_test_path).unwrap(); let entry = DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }; server.documents.write().await.insert(uri.clone(), entry); let params = DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }, work_done_progress_params: WorkDoneProgressParams::default(), }; let result = server.formatting(params).await.unwrap(); assert!(result.is_some(), "Formatting should return edits"); let edits = result.unwrap(); assert!(!edits.is_empty(), "Should have at least one edit"); let formatted_text = &edits[0].new_text; assert!( formatted_text.contains(" - Nested bullet"), "Formatted text should have 4-space indent, got:\n{formatted_text}", ); assert!( !formatted_text.contains("\n - Nested"), "Formatted text should NOT have 2-space indent, got:\n{formatted_text}", ); } /// Test that the source.fixAll.rumdl code action path (used by Zed's code_actions_on_format) /// correctly applies MD007 indent=4 config. This is the other path editors can use /// besides textDocument/formatting. #[tokio::test] async fn test_lsp_md007_code_action_fix_all_respects_indent_config() { use tempfile::tempdir; let server = create_test_server(); let temp_dir = tempdir().expect("Failed to create temp dir"); let config_path = temp_dir.path().join(".rumdl.toml"); std::fs::write( &config_path, r#" [ul-indent] indent = 4 style = "fixed" "#, ) .expect("Failed to write .rumdl.toml"); // User's exact test data from issue #210 let content = "- Bullet item\n - Nested bullet\n 1. Ordered child\n - Bullet under ordered\n"; let test_md_path = temp_dir.path().join("test.md"); std::fs::write(&test_md_path, content).expect("Failed to write test.md"); let canonical_temp = temp_dir.path().resolve_like_server(); server.workspace_roots.write().await.push(canonical_temp.clone()); let canonical_test_path = test_md_path.resolve_like_server(); let uri = Url::from_file_path(&canonical_test_path).unwrap(); let entry = DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }; server.documents.write().await.insert(uri.clone(), entry); // Request code actions for the full document (simulates code_actions_on_format) let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 3, character: 26 }, }; let actions = server.get_code_actions(&uri, content, range).await.unwrap(); // Find the source.fixAll.rumdl action let fix_all_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .collect(); assert!( !fix_all_actions.is_empty(), "source.fixAll.rumdl action should be created" ); // Extract the fixed content from the action's workspace edit let fix_all = &fix_all_actions[0]; let edit = fix_all.edit.as_ref().expect("fixAll action should have an edit"); let changes = edit.changes.as_ref().expect("edit should have changes"); let text_edits = changes.get(&uri).expect("changes should include our file"); let fixed_text = &text_edits[0].new_text; // Verify 4-space indent for nested bullet (depth 1) assert!( fixed_text.contains("\n - Nested bullet"), "source.fixAll should produce 4-space indent, got:\n{fixed_text}", ); assert!( !fixed_text.contains("\n - Nested"), "source.fixAll should NOT have 2-space indent, got:\n{fixed_text}", ); } // ============================================================================= // Navigation tests: go-to-definition and find-references // ============================================================================= #[tokio::test] async fn test_goto_definition_file_path_only() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); // Set up file paths let docs_dir = test_temp_path("rumdl-nav-test/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Content with a link to guide.md (cursor will be on the link target) let content = "# Index\n\nSee [the guide](guide.md) for details.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Populate workspace index with target file { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Position cursor on "guide.md" in `](guide.md)` // Line 2 (0-indexed): "See [the guide](guide.md) for details." // The `](` is at column 15, so "guide.md" starts at column 17 let position = Position { line: 2, character: 20 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should return a definition location"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "Should point to guide.md" ); // No anchor, so should target line 0 assert_eq!(location.range.start.line, 0, "Should target line 0 (top of file)"); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_root_relative_anchor_resolves_line_from_disk() { use std::fs; use tempfile::tempdir; // A root-relative anchor link `](/guide.md#configuration)` into a content // root outside the workspace must land on the heading line, not line 0. The // target is never indexed, so the line is parsed from disk. let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let workspace = root.join("workspace"); let content_root = root.join("site"); fs::create_dir(&workspace).unwrap(); fs::create_dir(&content_root).unwrap(); let current_file = workspace.join("index.md"); let target_file = content_root.join("guide.md"); fs::write(¤t_file, "").unwrap(); fs::write(&target_file, "# Guide\n\n## Configuration\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![workspace.clone()]; server.config.write().await.link_completion_content_roots = vec![content_root.to_string_lossy().into_owned()]; let current_uri = Url::from_file_path(¤t_file).unwrap(); let content = "See [config](/guide.md#configuration).\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on the link target. let position = Position { line: 0, character: 20 }; let result = server.handle_goto_definition(¤t_uri, position).await; match result { Some(GotoDefinitionResponse::Scalar(location)) => { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "should resolve under the content root" ); assert_eq!( location.range.start.line, 2, "anchor must land on the '## Configuration' heading parsed from disk" ); } other => panic!("expected a scalar definition, got: {other:?}"), } } /// Navigation into a file the index does not hold parses it in its own scope. /// /// A nested config governs how the workspace index generates that file's /// anchors, so a fallback reading the root config looks up an anchor the file /// never had and silently lands on line 0 instead of the heading. Hover /// previews resolve the same way. #[tokio::test] async fn test_goto_definition_disk_fallback_uses_the_target_scope() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let nested = root.join("docs"); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&nested).unwrap(); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( root.join(".rumdl.toml"), "[global]\nflavor = \"standard\"\n\n[MD051]\nanchor-style = \"python-markdown\"\n", ) .unwrap(); fs::write( nested.join(".rumdl.toml"), "[global]\nflavor = \"standard\"\n\n[MD051]\nanchor-style = \"github\"\n", ) .unwrap(); // The heading sits below the first line, so resolving it is distinguishable // from the line 0 an unresolved anchor falls back to. let target_file = nested.join("guide.md"); fs::write(&target_file, "Intro.\n\n# Getting Started โ€” Advanced\n\nBody.\n").unwrap(); let current_file = nested.join("index.md"); fs::write(¤t_file, "").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; // Control: the nested scope is what interprets this document. let effective = server .resolve_config_for_file_impl(&target_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( effective .rules .get("MD051") .and_then(|rule| rule.values.get("anchor-style")) .map(ToString::to_string), Some("\"github\"".to_string()), "control: per-file resolution must see the nested anchor style" ); // Control: the target is absent from the index, so navigation reads disk. assert!( server.workspace_index.read().await.get_file(&target_file).is_none(), "control: the target must not be indexed" ); let current_uri = Url::from_file_path(¤t_file).unwrap(); server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: "See [guide](guide.md#getting-started--advanced).\n".to_string(), version: Some(1), from_disk: false, }, ); let position = Position { line: 0, character: 20 }; match server.handle_goto_definition(¤t_uri, position).await { Some(GotoDefinitionResponse::Scalar(location)) => { assert_eq!(location.uri, Url::from_file_path(&target_file).unwrap()); assert_eq!( location.range.start.line, 2, "the nested config's anchor style must land on the heading, not line 0" ); } other => panic!("expected a scalar definition, got: {other:?}"), } } #[tokio::test] async fn test_goto_definition_root_relative_resolves_against_content_root() { use std::fs; use tempfile::tempdir; // A root-relative link `](/guide.md)` accepted from the absolute completion // must navigate to the content root, not the OS filesystem root. The content // root here lives outside the workspace, so resolution is on-disk only. let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let workspace = root.join("workspace"); let content_root = root.join("site"); fs::create_dir(&workspace).unwrap(); fs::create_dir(&content_root).unwrap(); let current_file = workspace.join("index.md"); let target_file = content_root.join("guide.md"); fs::write(¤t_file, "").unwrap(); fs::write(&target_file, "# Guide\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![workspace.clone()]; server.config.write().await.link_completion_content_roots = vec![content_root.to_string_lossy().into_owned()]; let current_uri = Url::from_file_path(¤t_file).unwrap(); let content = "See [the guide](/guide.md) for details.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on `/guide.md` inside the link target. let position = Position { line: 0, character: 20 }; let result = server.handle_goto_definition(¤t_uri, position).await; match result { Some(GotoDefinitionResponse::Scalar(location)) => assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "root-relative link should resolve under the content root" ), other => panic!("expected a definition under the content root, got: {other:?}"), } } #[tokio::test] async fn test_watched_file_eviction_when_newly_ignored() { use crate::workspace_index::{FileIndex, WorkspaceIndex}; use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; // A file indexed before an ignore rule began matching it must be evicted // when a later filesystem-watch event arrives, so completions and navigation // stop surfacing it without waiting for a full rescan. let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let draft = root.join("draft.md"); fs::write(&draft, "# Draft\n").unwrap(); fs::write(root.join(".gitignore"), "draft.md\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; { let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); index.insert_file(draft.clone(), FileIndex::default()); } let params = DidChangeWatchedFilesParams { changes: vec![FileEvent { uri: Url::from_file_path(&draft).unwrap(), typ: FileChangeType::CHANGED, }], }; server.did_change_watched_files(params).await; // The async index worker applies the eviction; poll until it lands. let mut evicted = false; for _ in 0..50 { if server.workspace_index.read().await.get_file(&draft).is_none() { evicted = true; break; } tokio::time::sleep(std::time::Duration::from_millis(20)).await; } assert!(evicted, "a newly-ignored file must be evicted from the workspace index"); } #[tokio::test] async fn test_goto_definition_file_with_anchor() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test2/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Content with a link that has both file and anchor let content = "# Index\n\nSee [install](guide.md#installation) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Populate workspace index with target file and heading { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Getting Started".to_string(), auto_anchor: "getting-started".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 10, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 25, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Position cursor on "guide.md#installation" // Line 2: "See [install](guide.md#installation) here." let position = Position { line: 2, character: 18 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should return a definition location for file+anchor"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "Should point to guide.md" ); // "Installation" heading is at line 10 (1-indexed) = line 9 (0-indexed) assert_eq!(location.range.start.line, 9, "Should target the Installation heading"); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_same_file_anchor() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-nav-test3/readme.md"); let uri = Url::from_file_path(&file).unwrap(); // Content with a same-file anchor link let content = "# Title\n\nSee [below](#configuration) for config.\n\n## Configuration\n\nSettings here.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Populate workspace index with the file's headings { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Title".to_string(), auto_anchor: "title".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 5, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } // Position cursor on "#configuration" in `](#configuration)` // Line 2: "See [below](#configuration) for config." let position = Position { line: 2, character: 16 }; let result = server.handle_goto_definition(&uri, position).await; assert!(result.is_some(), "Should return a definition for same-file anchor"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!(location.uri, uri, "Should point to the same file"); // "Configuration" heading is at line 5 (1-indexed) = line 4 (0-indexed) assert_eq!(location.range.start.line, 4, "Should target the Configuration heading"); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_cursor_not_on_link() { let server = create_test_server(); let file = test_temp_path("rumdl-nav-test4/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "# Title\n\nJust some plain text here.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Position cursor on plain text (no link) let position = Position { line: 2, character: 5 }; let result = server.handle_goto_definition(&uri, position).await; assert!(result.is_none(), "Should return None when cursor is not on a link"); } /// Index columns count characters, so a reference from a line with multibyte /// text before the link has to be converted by character, not sliced by byte. #[tokio::test] async fn test_find_references_positions_links_after_multibyte_text() { use crate::lsp::index_worker::cross_file_rules; for prefix in ["", "\u{feff}"] { let dir = tempfile::tempdir().unwrap(); let root = dir.path().resolve_like_server(); let target_file = root.join("t.md"); let source_file = root.join("s.md"); let target = "## Sub Part \u{1F600}\n\nText.\n"; let source = format!("{prefix}\u{1F600} \u{e9} \u{1F600}[x](t.md#sub-part-) tail\n"); std::fs::write(&target_file, target).unwrap(); std::fs::write(&source_file, &source).unwrap(); let server = create_test_server(); let target_uri = Url::from_file_path(&target_file).unwrap(); server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target.to_string(), version: Some(1), from_disk: false, }, ); { let rules = cross_file_rules(&Config::default()); let mut index = server.workspace_index.write().await; for (path, content) in [(&target_file, target), (&source_file, source.as_str())] { let file_index = crate::build_file_index_only( content, &rules, crate::config::MarkdownFlavor::Standard, Some(path.clone()), ); index.insert_file(path.clone(), file_index); } } // On the heading, and on body text, which lists every link to the file. for cursor in [Position { line: 0, character: 5 }, Position { line: 2, character: 1 }] { let locations = server .handle_references(&target_uri, cursor) .await .expect("the link references the file and its heading"); // The emoji immediately before `[` makes counting the BOM instead of // that emoji observably wrong: two pairs + two spaces + `รฉ` = 7. let source_uri = Url::from_file_path(&source_file).unwrap(); let starts: Vec<_> = locations .iter() .filter(|location| location.uri == source_uri) .map(|location| location.range.start) .collect(); assert_eq!( starts, [Position { line: 0, character: 7 }], "{cursor:?}: {locations:?}" ); } } } /// A workspace of `(file name, content)` pairs, written to disk, opened in a /// test server and indexed the way the index worker indexes them. async fn indexed_workspace(files: &[(&str, &str)]) -> (tempfile::TempDir, RumdlLanguageServer, Vec) { let dir = tempfile::tempdir().unwrap(); let root = dir.path().resolve_like_server(); let server = create_test_server(); let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); let mut uris = Vec::new(); for (name, content) in files { let path = root.join(name); std::fs::write(&path, content).unwrap(); let uri = Url::from_file_path(&path).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let file_index = crate::build_file_index_only( content, &rules, crate::config::MarkdownFlavor::Standard, Some(path.clone()), ); server.workspace_index.write().await.insert_file(path, file_index); uris.push(uri); } (dir, server, uris) } /// Text that only resembles a link, written beside real links on the same /// line, alongside a reference definition that is a link. const LINK_LOOKALIKES: &str = "\ [ref][r] and `[code](t.md#a)` here \\[escaped](t.md#a) text ![alt [inner](t.md#a)](img.png) [shortcut] `[span](t.md#a)` [real](t.md#b) [r]: t.md#c [shortcut]: t.md "; #[test] fn link_index_holds_parsed_links_and_definitions_only() { let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); let index = crate::build_file_index_only( LINK_LOOKALIKES, &rules, crate::config::MarkdownFlavor::Standard, Some(std::path::PathBuf::from("s.md")), ); // A link written in a comment is indexed under its own origin, so a consumer // that does not read comments can leave it out; it is checked separately. let (commented, rendered): (Vec<_>, Vec<_>) = index .cross_file_links .iter() .partition(|link| link.origin == crate::workspace_index::LinkOrigin::HtmlComment); assert_eq!( commented .iter() .map(|link| (link.target_path.as_str(), link.fragment.as_str(), link.line)) .collect::>(), [("t.md", "a", 2)], "{:#?}", index.cross_file_links ); let mut found: Vec<_> = rendered .iter() .map(|link| { ( link.target_path.as_str(), link.fragment.as_str(), link.line, link.column, ) }) .collect(); found.sort_unstable(); // Inline links report the link's start, definitions their destination's. assert_eq!( found, [("t.md", "", 8, 13), ("t.md", "b", 5, 29), ("t.md", "c", 7, 6)], "{:#?}", index.cross_file_links ); } /// Regions of a document, with `@@` where a link goes, and whether the renderer /// reads that place as Markdown of the document body. const LINK_REGIONS: &[(crate::config::MarkdownFlavor, &str, bool)] = { use crate::config::MarkdownFlavor::*; &[ (Standard, "@@", true), (Standard, "> @@", true), (Standard, "```\n@@\n```", false), (Standard, "~~~\n@@\n~~~", false), (Standard, " @@", false), (Standard, "---\nk: v\n@@\n---", false), (Standard, "", false), (Standard, "
\n@@\n
", false), (Standard, "$$\n@@\n$$", false), (Standard, "{%\n@@\n%}", false), (MkDocs, "$$\n@@\n$$", false), (MkDocs, "/// note\n@@\n///", false), (Kramdown, "{::comment}\n@@\n{:/comment}", false), (Kramdown, "{::nomarkdown}\n@@\n{:/nomarkdown}", false), (Obsidian, "%%\n@@\n%%", false), (MDX, "{/*\n@@\n*/}", false), (MDX, "{\n@@\n}", false), (Hugo, "{{< note\n@@\n>}}", false), (MyST, "```{code-block}\n@@\n```", false), (Quarto, "::: {.note}\n@@\n:::", true), (Quarto, "::: {.note}\n\n@@\n\n:::", true), ] }; /// Where a flavor's own block fence ends the block before it, a definition /// written directly after or before the fence line is one: the index holds /// it, MD051 checks its fragment and references resolve to it. Where the /// fence line is plain text, a line directly after it continues that /// paragraph and is text, while one after a blank line is a definition. #[test] fn definitions_beside_flavor_fences() { use crate::config::MarkdownFlavor::{Quarto, Standard}; use crate::rule::Rule; let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); let cases = [ (Quarto, "::: {.note}\n@@\n:::", true), (Quarto, "::: {.note}\nText.\n\n@@\n:::", true), (Quarto, ":::: {.outer}\n::: {.inner}\n@@\n:::\n::::", true), (Quarto, ":::: {.outer}\n::: {.inner}\nText.\n:::\n@@\n::::", true), (Standard, "::: {.note}\n@@\n:::", false), (Standard, "::: {.note}\nText.\n\n@@\n:::", true), ]; let mut wrong = Vec::new(); for (flavor, region, is_definition) in cases { let place = |definition: &str| format!("{}\n\nSee [text][d].\n\n# Real\n", region.replace("@@", definition)); let content = place("[d]: t.md#gone"); let index = crate::build_file_index_only(&content, &rules, flavor, Some(std::path::PathBuf::from("s.md"))); let indexed = index .cross_file_links .iter() .any(|link| link.origin == crate::workspace_index::LinkOrigin::Body && link.fragment == "gone"); let ctx = crate::lint_context::LintContext::new(&content, flavor, None); let resolved = ctx.get_reference_url("d") == Some("t.md#gone"); if indexed != is_definition || resolved != is_definition { wrong.push(format!( "{flavor:?} {content:?}: indexed {indexed}, resolved {resolved}" )); } let content = place("[d]: #gone"); let ctx = crate::lint_context::LintContext::new(&content, flavor, None); let warnings = crate::rules::MD051LinkFragments::default().check(&ctx).unwrap(); if warnings.iter().any(|warning| warning.message.contains("'#gone'")) != is_definition { wrong.push(format!("MD051 {flavor:?} {content:?}")); } } assert!(wrong.is_empty(), "{}", wrong.join("\n")); } /// Text shaped like a definition outside the document body never shadows the /// body definition of the same label: the index holds the body definition, /// MD057 and MD051 check it, and references resolve to it. #[test] fn definitions_outside_the_body_never_shadow_a_body_definition() { use crate::config::MarkdownFlavor::*; use crate::rule::Rule; let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); let cases = [ (Standard, "---\n@@\n---", "@@"), (Standard, "---\n@@\nk: v\n---", "@@"), (Standard, "---\nk: v\n@@\n---", "@@"), (Standard, "+++\n@@\n+++", "@@"), (Standard, "{\n\"k\": 1,\n@@\n}", "@@"), (MkDocs, "---\n@@\n---", "@@"), (Pandoc, "---\n@@\n---", "@@"), (Quarto, "---\n@@\n---", "@@"), (Quarto, "---\n@@\n---", "::: {.n}\n@@\n:::"), (MDX, "---\n@@\n---", "@@"), (Standard, "", "@@"), (Standard, "
\n@@\n
", "@@"), (Standard, "```\n@@\n```", "@@"), (Standard, "~~~\n@@\n~~~", "@@"), (Standard, "Text.\n\n @@", "@@"), (Standard, "$$\n@@\n$$", "@@"), (Standard, "{%\n@@\n%}", "@@"), (MkDocs, "/// note\n@@\n///", "@@"), (MkDocs, "::: my.module\n @@", "@@"), (MyST, "```{code-block}\n@@\n```", "@@"), (MDX, "{/*\n@@\n*/}", "@@"), (MDX, "{\n@@\n}", "@@"), (Kramdown, "{::comment}\n@@\n{:/comment}", "@@"), (Kramdown, "{::nomarkdown}\n@@\n{:/nomarkdown}", "@@"), (Obsidian, "%%\n@@\n%%", "@@"), (Hugo, "{{< note\n@@\n>}}", "@@"), ]; let dir = tempfile::tempdir().unwrap(); let mut wrong = Vec::new(); for (flavor, region, body) in cases { let document = |shadow: &str, real: &str| { format!( "{}\n\n{}\n\nSee [x][r].\n\n# Real\n", region.replace("@@", &format!("[r]: {shadow}")), body.replace("@@", &format!("[r]: {real}")) ) }; let content = document("shadow.md#s", "real.md#g"); let index = crate::build_file_index_only(&content, &rules, flavor, Some(std::path::PathBuf::from("s.md"))); let indexed: Vec<_> = index .cross_file_links .iter() .filter(|link| link.origin == crate::workspace_index::LinkOrigin::Body) .map(|link| link.target_path.as_str()) .collect(); let ctx = crate::lint_context::LintContext::new(&content, flavor, None); let resolved = ctx.get_reference_url("r"); let checked: Vec<_> = crate::rules::MD057ExistingRelativeLinks::default() .with_path(dir.path()) .check(&ctx) .unwrap() .into_iter() .map(|warning| warning.message) .collect(); let md057_real = checked.len() == 1 && checked[0].contains("'real.md#g'"); if indexed != ["real.md"] || resolved != Some("real.md#g") || !md057_real { wrong.push(format!( "{flavor:?} {content:?}: indexed {indexed:?}, resolved {resolved:?}, MD057 {checked:?}" )); } let content = document("#shadow", "#gone"); let ctx = crate::lint_context::LintContext::new(&content, flavor, None); let anchors: Vec<_> = crate::rules::MD051LinkFragments::default() .check(&ctx) .unwrap() .into_iter() .map(|warning| warning.message) .collect(); if anchors.len() != 1 || !anchors[0].contains("'#gone'") { wrong.push(format!("MD051 {flavor:?} {content:?}: {anchors:?}")); } } assert!(wrong.is_empty(), "{}", wrong.join("\n")); } /// A line shaped like a definition inside the title of another definition is /// title text: the index holds no link for it and MD051 does not check it, /// while the same line after a closed title is a definition both see. #[test] fn a_definition_shaped_line_inside_a_title_is_neither_indexed_nor_checked() { use crate::rule::Rule; let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); let flavor = crate::config::MarkdownFlavor::Standard; let cases = [ ("[a]: #real \"t\n@@\n\"", false), ("[a]: #real 't\n@@\n'", false), ("[a]: #real (t\n@@\n)", false), ("[a]: #real \"t\nmore\n@@\nmore\n\"", false), ("> [a]: #real \"t\n> @@\n> \"", false), ("- [a]: #real \"t\n @@\n \"", false), ("[a]: #real \"t\"\n@@", true), ("[a]: #real \"t\nx\"\n@@", true), ]; let mut wrong = Vec::new(); for (case, is_definition) in cases { let content = format!( "# Real\n\n{}\n\nSee [x][a] and [y][b].\n", case.replace("@@", "[b]: t.md#gone") ); let index = crate::build_file_index_only(&content, &rules, flavor, Some(std::path::PathBuf::from("s.md"))); let indexed = index .cross_file_links .iter() .any(|link| link.origin == crate::workspace_index::LinkOrigin::Body && link.target_path == "t.md"); if indexed != is_definition { wrong.push(format!("index {content:?}: {indexed}")); } let content = format!( "# Real\n\n{}\n\nSee [x][a] and [y][b].\n", case.replace("@@", "[b]: #gone") ); let ctx = crate::lint_context::LintContext::new(&content, flavor, None); let checked = crate::rules::MD051LinkFragments::default() .check(&ctx) .unwrap() .iter() .any(|warning| warning.message.contains("'#gone'")); if checked != is_definition { wrong.push(format!("MD051 {content:?}: {checked}")); } } assert!(wrong.is_empty(), "{}", wrong.join("\n")); } /// An inline link and a reference definition written in the same place are /// both read as links, or both as text: the index holds both or neither, and /// MD051 checks both or neither. #[test] fn inline_links_and_definitions_share_one_notion_of_body() { use crate::rule::Rule; let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); let mut wrong = Vec::new(); for &(flavor, region, is_body) in LINK_REGIONS { for (cross_file, same_file) in [("[i](t.md#gone)", "[i](#gone)"), ("[d]: t.md#gone", "[d]: #gone")] { let place = |link: &str| format!("{}\n\n# Real\n", region.replace("@@", link)); let content = place(cross_file); let index = crate::build_file_index_only(&content, &rules, flavor, Some(std::path::PathBuf::from("s.md"))); // Frontmatter values that read as paths are indexed under their // own origin; only Markdown links are in question here. let indexed = index .cross_file_links .iter() .any(|link| link.origin == crate::workspace_index::LinkOrigin::Body && link.fragment == "gone"); if indexed != is_body { wrong.push(format!("index {flavor:?} {content:?}")); } let content = place(same_file); let ctx = crate::lint_context::LintContext::new(&content, flavor, None); let warnings = crate::rules::MD051LinkFragments::default().check(&ctx).unwrap(); if warnings.iter().any(|warning| warning.message.contains("'#gone'")) != is_body { wrong.push(format!("MD051 {flavor:?} {content:?}")); } } } assert!( wrong.is_empty(), "read against the region's body status:\n{}", wrong.join("\n") ); } #[tokio::test] async fn references_skip_lookalikes_and_include_definitions() { let target = "# Doc\n\n## A\n\n## B\n\n## C\n"; let (_dir, server, uris) = indexed_workspace(&[("t.md", target), ("s.md", LINK_LOOKALIKES)]).await; let (target_uri, source_uri) = (&uris[0], &uris[1]); let references = |line: u32| { let server = &server; async move { server .handle_references(target_uri, Position { line, character: 3 }) .await .unwrap_or_default() .into_iter() .filter(|location| &location.uri == source_uri) .map(|location| (location.range.start.line, location.range.start.character)) .collect::>() } }; assert_eq!(references(2).await, [], "nothing links to `#a`"); assert_eq!(references(4).await, [(4, 28)]); assert_eq!(references(6).await, [(6, 5)], "the definition links to `#c`"); } /// Apply a workspace edit's changes for `uri` to `text` the way a client does: /// every edit addresses the original text, and no two of them may overlap. fn apply_workspace_edit(edit: &WorkspaceEdit, uri: &Url, text: &str) -> String { let Some(edits) = edit.changes.as_ref().and_then(|changes| changes.get(uri)) else { return text.to_string(); }; let mut edits: Vec<_> = edits .iter() .map(|edit| { let start = crate::lsp::position::lsp_position_to_byte_offset(text, edit.range.start); let end = crate::lsp::position::lsp_position_to_byte_offset(text, edit.range.end); (start, end, edit.new_text.as_str()) }) .collect(); edits.sort_by_key(|&(start, end, _)| (start, end)); let mut result = String::new(); let mut copied = 0; for (start, end, new_text) in edits { assert!(copied <= start && start <= end, "overlapping edits for {uri}: {edit:?}"); result.push_str(&text[copied..start]); result.push_str(new_text); copied = end; } result.push_str(&text[copied..]); result } /// Rename the heading on the 0-based `line` of the first file and return every /// file's content with the resulting workspace edit applied. async fn renamed_workspace(files: &[(&str, &str)], line: u32, new_name: &str) -> Vec { let (_dir, server, uris) = indexed_workspace(files).await; let edit = server .handle_rename(&uris[0], Position { line, character: 4 }, new_name) .await .expect("the rename is accepted"); uris.iter() .zip(files) .map(|(uri, (_, content))| apply_workspace_edit(&edit, uri, content)) .collect() } #[tokio::test] async fn rename_rewrites_exactly_the_links_to_the_renamed_heading() { let target = "\ # Setup [self](#setup) and [other](o.md#setup) and `[code](#setup)` here [pre](#setup-1) [enc](#setup%20x) [upper](#SETUP) [title](#setup \"#setup\") [#setup][q] and [path](t.md#setup) and [dec](#%73etup) ```text [f]: #setup ``` [q]: #setup "; let source = "\ [a](t.md#setup) [b](o.md#setup) [c](t.md#setup-1) `[d](t.md#setup)` [e][d] [f]() ฤฐฤฐ [g](t.md#setup) [d]: t.md#Setup \"t.md#setup\" "; let other = "# Setup\n\n[back](t.md#setup) [own](#setup)\n"; let renamed = renamed_workspace(&[("t.md", target), ("s.md", source), ("o.md", other)], 0, "Install").await; assert_eq!( renamed[0], "\ # Install [self](#install) and [other](o.md#setup) and `[code](#setup)` here [pre](#setup-1) [enc](#setup%20x) [upper](#install) [title](#install \"#setup\") [#setup][q] and [path](t.md#install) and [dec](#install) ```text [f]: #setup ``` [q]: #install " ); assert_eq!( renamed[1], "\ [a](t.md#install) [b](o.md#setup) [c](t.md#setup-1) `[d](t.md#setup)` [e][d] [f]() ฤฐฤฐ [g](t.md#install) [d]: t.md#install \"t.md#setup\" " ); assert_eq!(renamed[2], "# Setup\n\n[back](t.md#install) [own](#setup)\n"); } /// Renaming one of several headings with the same text moves the numbered /// anchors of the later ones, and links to those follow their headings. #[tokio::test] async fn rename_moves_links_to_siblings_whose_anchors_shift() { let target = "\ # Doc ## Setup ## Setup ## Setup [a](#setup) [b](#setup-1) [c](#setup-2) "; let source = "[a](t.md#setup) [b](t.md#setup-1) [c](t.md#setup-2)\n"; let files = [("t.md", target), ("s.md", source)]; let first = renamed_workspace(&files, 2, "Install").await; assert!( first[0].ends_with("[a](#install) [b](#setup) [c](#setup-1)\n"), "{}", first[0] ); assert!( first[0].starts_with("# Doc\n\n## Install\n\n## Setup\n"), "{}", first[0] ); assert_eq!(first[1], "[a](t.md#install) [b](t.md#setup) [c](t.md#setup-1)\n"); let second = renamed_workspace(&files, 4, "Install").await; assert!( second[0].ends_with("[a](#setup) [b](#install) [c](#setup-1)\n"), "{}", second[0] ); assert_eq!(second[1], "[a](t.md#setup) [b](t.md#install) [c](t.md#setup-1)\n"); let last = renamed_workspace(&files, 6, "Install").await; assert!( last[0].ends_with("[a](#setup) [b](#setup-1) [c](#install)\n"), "{}", last[0] ); assert_eq!(last[1], "[a](t.md#setup) [b](t.md#setup-1) [c](t.md#install)\n"); } /// Inline links with the path written as `P` and the fragment as `F`, in every /// CommonMark spelling of a destination and title. const INLINE_LINK_FORMS: &[&str] = &[ "[x](P#F)", "[x](P#F \"#F\")", "[x](P#F '#F')", "[x](P#F (#F))", "[x]()", "[x]( '#F')", "[x](P#F\n '#F')", "[x]( P#F\t)", "[x](\nP#F\n)", ]; /// The paths each form is tried with: bare destinations cannot hold a space, /// angle brackets can. fn inline_link_form_paths(form: &str) -> &'static [&'static str] { if form.contains('<') { &["t.md", "f(1).md", "t x.md"] } else { &["t.md", "f(1).md", "f((1)).md"] } } /// LSP range of the first `#F` fragment, without its `#`, in `text`. fn first_fragment_range(text: &str, fragment: &str) -> Range { let start = text.find(&format!("#{fragment}")).unwrap() + 1; crate::lsp::position::byte_range_to_lsp_range(text, start..start + fragment.len()).unwrap() } #[tokio::test] async fn every_inline_link_form_is_indexed_referenced_and_renamed() { let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); for form in INLINE_LINK_FORMS { for path in inline_link_form_paths(form) { let source = format!("{}\n", form.replace('P', path).replace('F', "setup")); let index = crate::build_file_index_only( &source, &rules, crate::config::MarkdownFlavor::Standard, Some(std::path::PathBuf::from("s.md")), ); let indexed: Vec<_> = index .cross_file_links .iter() .map(|link| { ( link.target_path.as_str(), link.fragment.as_str(), link.line, link.column, ) }) .collect(); assert_eq!(indexed, [(*path, "setup", 1, 1)], "{source:?}"); let (_dir, server, uris) = indexed_workspace(&[(path, "# Setup\n"), ("s.md", &source)]).await; let references: Vec<_> = server .handle_references(&uris[0], Position { line: 0, character: 3 }) .await .unwrap_or_default() .into_iter() .filter(|location| location.uri == uris[1]) .map(|location| location.range.start) .collect(); assert_eq!(references, [Position { line: 0, character: 0 }], "{source:?}"); let edit = server .handle_rename(&uris[0], Position { line: 0, character: 4 }, "Install") .await .expect("the rename is accepted"); let edits = edit.changes.as_ref().and_then(|changes| changes.get(&uris[1])); assert_eq!( edits.map(Vec::as_slice), Some( &[TextEdit { range: first_fragment_range(&source, "setup"), new_text: "install".to_string(), }][..] ), "{source:?}" ); } let target = format!("# Setup\n\n{}\n", form.replace('P', "").replace('F', "setup")); let renamed = renamed_workspace(&[("t.md", &target)], 0, "Install").await; assert_eq!( renamed[0], target .replacen("# Setup", "# Install", 1) .replacen("#setup", "#install", 1), "{target:?}" ); } } #[tokio::test] async fn inline_links_wrapped_inside_containers_are_indexed_referenced_and_renamed() { // Containers as the prefix of a link's first line and of its // continuation lines. const CONTAINERS: &[(&str, &str)] = &[ ("> ", "> "), ("> > ", "> > "), (">> ", ">>"), ("- ", " "), ("- > ", " > "), ("> - ", "> "), ("- ", "\t"), ("> -\t", ">\t "), ]; // Destination, title, or both on a continuation line opening with `C`. const FORMS: &[&str] = &[ "[x](\nCt.md#setup)", "[x](t.md#setup\nC\"title\")", "[x](\nCt.md#setup\nC'title')", "[x](\nC)", ]; let rules = crate::lsp::index_worker::cross_file_rules(&Config::default()); for (first, continuation) in CONTAINERS { for form in FORMS { let source = format!("{first}{}\n", form.replace('C', continuation)); let column = first.chars().count() as u32; let index = crate::build_file_index_only( &source, &rules, crate::config::MarkdownFlavor::Standard, Some(std::path::PathBuf::from("s.md")), ); let indexed: Vec<_> = index .cross_file_links .iter() .map(|link| { ( link.target_path.as_str(), link.fragment.as_str(), link.line, link.column, ) }) .collect(); assert_eq!(indexed, [("t.md", "setup", 1, column as usize + 1)], "{source:?}"); let (_dir, server, uris) = indexed_workspace(&[("t.md", "# Setup\n"), ("s.md", &source)]).await; let references: Vec<_> = server .handle_references(&uris[0], Position { line: 0, character: 3 }) .await .unwrap_or_default() .into_iter() .filter(|location| location.uri == uris[1]) .map(|location| location.range.start) .collect(); assert_eq!( references, [Position { line: 0, character: column }], "{source:?}" ); let edit = server .handle_rename(&uris[0], Position { line: 0, character: 4 }, "Install") .await .expect("the rename is accepted"); let edits = edit.changes.as_ref().and_then(|changes| changes.get(&uris[1])); assert_eq!( edits.map(Vec::as_slice), Some( &[TextEdit { range: first_fragment_range(&source, "setup"), new_text: "install".to_string(), }][..] ), "{source:?}" ); } } } /// Text written in place of `D`, a destination, with whether the parser reads /// it as a link reference definition of that destination. const DEFINITION_CANDIDATES: &[(&str, bool)] = &[ ("[r]: D", true), ("[r]: D \"title\"", true), ("[r]:\nD\n'title'", true), ("- [r]: D", true), ("> - [r]: D", true), ("> [r]:\n> D", true), ("- [r]:\n D", true), ("> > [r]:\n> > D \"title\"", true), // A definition cannot interrupt a paragraph, in a container or not. ("Text\n[r]: D", false), ("- item\n [r]: D", false), ("> quote\n> [r]: D", false), ("- item\n[r]: D", false), // Indented four columns, it is code. (" [r]: D", false), ("- item\n\n [r]: D", false), // A later definition of the same label defines nothing. ("[r]: other.md\n[r]: D", false), ("[R]: other.md\n[ r ]: D", false), // Text after the destination that is not a title. ("[r]: D junk", false), ("[r]: D \"title\" junk", false), ("[r]: D 'open", false), ("```\n[r]: D\n```", false), ("", false), ]; /// Every definition the parser reads is checked, indexed, referenced and /// renamed, at its destination; text the parser reads otherwise is none of /// these, however much it looks like a definition. #[tokio::test] async fn reference_definitions_are_exactly_the_parsers() { use crate::rule::Rule; let md051 = crate::rules::MD051LinkFragments::default(); for &(text, defines) in DEFINITION_CANDIDATES { let parser_defines = |source: &str, destination: &str| { let options = crate::utils::parser_options::rumdl_parser_options_for(source); pulldown_cmark::Parser::new_ext(source, options) .reference_definitions() .iter() .any(|(_, definition)| definition.dest.as_ref() == destination) }; // Same file: a missing anchor is reported at the destination. let content = format!("# Setup\n\n{}\n", text.replace('D', "#missing")); assert_eq!(parser_defines(&content, "#missing"), defines, "{content:?}"); let ctx = crate::lint_context::LintContext::new(&content, crate::config::MarkdownFlavor::Standard, None); let found: Vec<_> = md051 .check(&ctx) .unwrap() .into_iter() .map(|w| (w.line, w.column, w.end_line, w.end_column)) .collect(); let expected: Vec<_> = defines .then(|| { let start = content.find("#missing").unwrap(); let (_, line, column) = crate::lint_context::SourcePositions::new(&content, &ctx.lines).position(start); (line, column + 1, line, column + 1 + "#missing".len()) }) .into_iter() .collect(); assert_eq!(found, expected, "{content:?}"); // Another file: indexed at the destination, checked against the // target, found by references and renamed exactly there. for fragment in ["setup", "missing"] { let destination = format!("t.md#{fragment}"); let source = format!("# S\n\n{}\n", text.replace('D', &destination)); assert_eq!(parser_defines(&source, &destination), defines, "{source:?}"); let (dir, server, uris) = indexed_workspace(&[("t.md", "# Setup\n"), ("s.md", &source)]).await; let start = crate::lsp::position::byte_range_to_lsp_range(&source, { let at = source.find(&destination).unwrap(); at..at }) .unwrap() .start; let path = dir.path().resolve_like_server().join("s.md"); let workspace = server.workspace_index.read().await; let file_index = workspace.get_file(&path).expect("s.md is indexed"); // The candidates that repeat a label also define it to `other.md`. let indexed: Vec<_> = file_index .cross_file_links .iter() .filter(|link| link.target_path == "t.md") .map(|link| (link.target_path.clone(), link.fragment.clone(), link.line, link.column)) .collect(); let expected: Vec<_> = defines .then(|| { ( "t.md".to_string(), fragment.to_string(), start.line as usize + 1, start.character as usize + 1, ) }) .into_iter() .collect(); assert_eq!(indexed, expected, "{source:?}"); let reported: Vec<_> = md051 .cross_file_check(&path, file_index, &workspace) .unwrap() .into_iter() .map(|w| (w.line, w.column)) .collect(); let expected: Vec<_> = (defines && fragment == "missing") .then_some((start.line as usize + 1, start.character as usize + 1)) .into_iter() .collect(); assert_eq!(reported, expected, "{source:?}"); drop(workspace); if fragment != "setup" { continue; } let references: Vec<_> = server .handle_references(&uris[0], Position { line: 0, character: 3 }) .await .unwrap_or_default() .into_iter() .filter(|location| location.uri == uris[1]) .map(|location| location.range.start) .collect(); assert_eq!( references, defines.then_some(start).into_iter().collect::>(), "{source:?}" ); let edit = server .handle_rename(&uris[0], Position { line: 0, character: 4 }, "Install") .await .expect("the rename is accepted"); let edits = edit .changes .as_ref() .and_then(|changes| changes.get(&uris[1])) .cloned() .unwrap_or_default(); let expected: Vec<_> = defines .then(|| TextEdit { range: first_fragment_range(&source, "setup"), new_text: "install".to_string(), }) .into_iter() .collect(); assert_eq!(edits, expected, "{source:?}"); } } } /// A definition's destination is the parser's: escapes and entities are /// decoded before it is checked, indexed or referenced. Only a destination /// written exactly as it reads is renamed, since the new fragment would /// otherwise replace a spelling it does not match. #[tokio::test] async fn reference_definition_destinations_are_read_decoded() { use crate::rule::Rule; let md051 = crate::rules::MD051LinkFragments::default(); // Same file: the entity and escape spell `#a-b`, which resolves. for written in ["#a-b", "#a-b", "#a-b", "#a\\-b", "<#a-b>"] { for (heading, reported) in [("A-b", false), ("Other", true)] { let content = format!("# {heading}\n\n[r]: {written}\n"); let ctx = crate::lint_context::LintContext::new(&content, crate::config::MarkdownFlavor::Standard, None); let found: Vec<_> = md051 .check(&ctx) .unwrap() .into_iter() .map(|w| (w.line, w.column, w.message)) .collect(); let column = 6 + usize::from(written.starts_with('<')); let expected: Vec<_> = reported .then(|| { ( 3, column, "Link anchor '#a-b' does not exist in document headings".to_string(), ) }) .into_iter() .collect(); assert_eq!(found, expected, "{content:?}"); } } // Another file: the decoded fragment is indexed and referenced at the // destination; only the literal spelling is renamed. for (written, renamed) in [ ("t.md#setup", true), ("", true), ("t.md#setup", false), ("t.md#setup", false), ("t\\.md#setup", false), ("t.md#set\\up", false), ] { let source = format!("# S\n\n[r]: {written}\n"); let (dir, server, uris) = indexed_workspace(&[("t.md", "# Setup\n"), ("s.md", &source)]).await; let column = 6 + usize::from(written.starts_with('<')); let path = dir.path().resolve_like_server().join("s.md"); let indexed: Vec<_> = server .workspace_index .read() .await .get_file(&path) .expect("s.md is indexed") .cross_file_links .iter() .map(|link| (link.target_path.clone(), link.fragment.clone(), link.line, link.column)) .collect(); let fragment = if written.ends_with("set\\up") { "set\\up" } else { "setup" }; assert_eq!( indexed, [("t.md".to_string(), fragment.to_string(), 3, column)], "{source:?}" ); if fragment != "setup" { continue; } let references: Vec<_> = server .handle_references(&uris[0], Position { line: 0, character: 3 }) .await .unwrap_or_default() .into_iter() .filter(|location| location.uri == uris[1]) .map(|location| location.range.start) .collect(); assert_eq!( references, [Position { line: 2, character: column as u32 - 1 }], "{source:?}" ); let edit = server .handle_rename(&uris[0], Position { line: 0, character: 4 }, "Install") .await .expect("the rename is accepted"); let edits = edit .changes .as_ref() .and_then(|changes| changes.get(&uris[1])) .cloned() .unwrap_or_default(); let expected: Vec<_> = renamed .then(|| TextEdit { range: first_fragment_range(&source, "setup"), new_text: "install".to_string(), }) .into_iter() .collect(); assert_eq!(edits, expected, "{source:?}"); } } #[tokio::test] async fn test_find_references_heading_with_incoming_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test5/docs"); let target_file = docs_dir.join("guide.md"); let source_file_a = docs_dir.join("index.md"); let source_file_b = docs_dir.join("faq.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); // Target file content with the heading let content = "# Installation\n\nHow to install.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Populate workspace index: target file has heading, two source files link to it { let mut index = server.workspace_index.write().await; // Target file with heading let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); // Source file A links to guide.md#installation let mut source_a_fi = FileIndex::default(); source_a_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 5, column: 10, origin: LinkOrigin::Body, }); index.insert_file(source_file_a.clone(), source_a_fi); // Source file B also links to guide.md#installation let mut source_b_fi = FileIndex::default(); source_b_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 3, column: 15, origin: LinkOrigin::Body, }); index.insert_file(source_file_b.clone(), source_b_fi); } // Position cursor on the heading "# Installation" (line 0, any column) let position = Position { line: 0, character: 5 }; let result = server.handle_references(&target_uri, position).await; assert!(result.is_some(), "Should find references to the heading"); let locations = result.unwrap(); assert_eq!(locations.len(), 2, "Should find 2 references from two files"); let uris: Vec<_> = locations.iter().map(|l| l.uri.clone()).collect(); assert!( uris.contains(&Url::from_file_path(&source_file_a).unwrap()), "Should include reference from index.md" ); assert!( uris.contains(&Url::from_file_path(&source_file_b).unwrap()), "Should include reference from faq.md" ); // Verify line/column conversion (1-indexed to 0-indexed) let a_loc = locations .iter() .find(|l| l.uri == Url::from_file_path(&source_file_a).unwrap()) .unwrap(); assert_eq!( a_loc.range.start.line, 4, "Line 5 (1-indexed) should become 4 (0-indexed)" ); assert_eq!( a_loc.range.start.character, 9, "Column 10 (1-indexed) should become 9 (0-indexed)" ); } /// A frontmatter value pointing at a heading is indexed so MD051 can validate /// it on request, but it is not Markdown link syntax, so rename cannot rewrite /// it. Listing it here would hand the editor a location a later rename leaves /// silently stale, so find-references reports only the body link. #[tokio::test] async fn test_find_references_excludes_frontmatter_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-frontmatter-refs/docs"); let target_file = docs_dir.join("guide.md"); let body_source = docs_dir.join("index.md"); let frontmatter_source = docs_dir.join("faq.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "# Installation\n\nHow to install.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); // The positive control: an ordinary body link to the same anchor is // listed under every configuration, so an empty result would be a // broken fixture rather than the frontmatter filter. let mut body_fi = FileIndex::default(); body_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 5, column: 10, origin: LinkOrigin::Body, }); index.insert_file(body_source.clone(), body_fi); let mut frontmatter_fi = FileIndex::default(); frontmatter_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 2, column: 7, origin: LinkOrigin::FrontMatter { field: Some("link".to_string()), }, }); index.insert_file(frontmatter_source.clone(), frontmatter_fi); } let position = Position { line: 0, character: 5 }; let locations = server .handle_references(&target_uri, position) .await .expect("the body link is a reference, so the query resolves"); let uris: Vec<_> = locations.iter().map(|l| l.uri.clone()).collect(); assert!( uris.contains(&Url::from_file_path(&body_source).unwrap()), "the body link must be listed" ); assert!( !uris.contains(&Url::from_file_path(&frontmatter_source).unwrap()), "the frontmatter value must not be listed, got {uris:?}" ); } /// The same exclusion on the fallback path, which matches by file rather than /// by anchor and is reached when the cursor is on neither a heading nor a link. #[tokio::test] async fn test_find_references_fallback_excludes_frontmatter_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-frontmatter-fallback/docs"); let target_file = docs_dir.join("file-to-link-to.md"); let body_source = docs_dir.join("body-source.md"); let frontmatter_source = docs_dir.join("frontmatter-source.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "---\ntitle: Heading\n---\n\nWe are linking to this file.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; index.insert_file(target_file.clone(), FileIndex::default()); let mut body_fi = FileIndex::default(); body_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "file-to-link-to.md".to_string(), fragment: String::new(), line: 5, column: 22, origin: LinkOrigin::Body, }); index.insert_file(body_source.clone(), body_fi); let mut frontmatter_fi = FileIndex::default(); frontmatter_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "file-to-link-to.md".to_string(), fragment: String::new(), line: 2, column: 7, origin: LinkOrigin::FrontMatter { field: None }, }); index.insert_file(frontmatter_source.clone(), frontmatter_fi); } let position = Position { line: 4, character: 10 }; let locations = server .handle_references(&target_uri, position) .await .expect("the body link is a reference, so the fallback resolves"); let uris: Vec<_> = locations.iter().map(|l| l.uri.clone()).collect(); assert_eq!( uris, vec![Url::from_file_path(&body_source).unwrap()], "only the body link is a navigable reference" ); } #[tokio::test] async fn test_find_references_finds_root_relative_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; use std::fs; use tempfile::tempdir; // find-references on a heading must discover root-relative links (`/guide.md`) // that point to it, resolving them against the content roots the same way // go-to-definition does. let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let target_file = root.join("guide.md"); let source_file = root.join("index.md"); fs::write(&target_file, "# Installation\n\nHow to install.\n").unwrap(); fs::write(&source_file, "See [install](/guide.md#installation).\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; let target_uri = Url::from_file_path(&target_file).unwrap(); server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: "# Installation\n\nHow to install.\n".to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); // The source file links via a root-relative path, stored leading-`/`-stripped. let mut source_fi = FileIndex::default(); source_fi.add_root_relative_link(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 1, column: 15, origin: LinkOrigin::Body, }); index.insert_file(source_file.clone(), source_fi); } // Cursor on the "# Installation" heading. let position = Position { line: 0, character: 5 }; let result = server.handle_references(&target_uri, position).await; let locations = result.expect("should find the root-relative reference"); assert_eq!(locations.len(), 1, "exactly one root-relative reference"); assert_eq!( locations[0].uri, Url::from_file_path(&source_file).unwrap(), "reference should point to the linking file" ); } /// A root-relative link written in a comment, or in frontmatter, is indexed /// for the rules but is not a link the editor navigates by: a rename cannot /// rewrite it, so find-references must not list it. The body link beside it is /// the positive control. #[tokio::test] async fn test_find_references_excludes_non_navigable_root_relative_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let root = temp_dir.path().resolve_like_server(); let target_file = root.join("guide.md"); fs::write(&target_file, "# Installation\n\nHow to install.\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; let target_uri = Url::from_file_path(&target_file).unwrap(); server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: "# Installation\n\nHow to install.\n".to_string(), version: Some(1), from_disk: false, }, ); let sources = [ ("body.md", LinkOrigin::Body), ("comment.md", LinkOrigin::HtmlComment), ("front.md", LinkOrigin::FrontMatter { field: None }), ]; { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); for (name, origin) in &sources { let mut fi = FileIndex::default(); fi.add_root_relative_link(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 1, column: 15, origin: origin.clone(), }); index.insert_file(root.join(name), fi); } } // On the heading: the by-anchor path. let by_anchor = server .handle_references(&target_uri, Position { line: 0, character: 5 }) .await .expect("the body link is a reference"); let uris: Vec<_> = by_anchor.iter().map(|l| l.uri.clone()).collect(); assert_eq!( uris, vec![Url::from_file_path(root.join("body.md")).unwrap()], "{uris:?}" ); // On plain text: the by-file fallback path. let by_file = server .handle_references(&target_uri, Position { line: 2, character: 3 }) .await .expect("the body link is a reference"); let uris: Vec<_> = by_file.iter().map(|l| l.uri.clone()).collect(); assert_eq!( uris, vec![Url::from_file_path(root.join("body.md")).unwrap()], "{uris:?}" ); } #[tokio::test] async fn test_find_references_heading_no_incoming_links() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-nav-test6/docs/lonely.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "# Lonely Heading\n\nNo one links here.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Lonely Heading".to_string(), auto_anchor: "lonely-heading".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } // Position cursor on the heading let position = Position { line: 0, character: 5 }; let result = server.handle_references(&uri, position).await; assert!(result.is_none(), "Should return None when no references exist"); } #[tokio::test] async fn test_goto_definition_with_custom_anchor() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test7/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Link uses a custom anchor let content = "# Index\n\nSee [install](guide.md#install) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Installation Guide".to_string(), auto_anchor: "installation-guide".to_string(), custom_anchor: Some("install".to_string()), line: 15, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Position cursor on the link target let position = Position { line: 2, character: 18 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should resolve custom anchor"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { // Line 15 (1-indexed) = line 14 (0-indexed) assert_eq!( location.range.start.line, 14, "Should target the heading with the custom anchor" ); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_anchor_not_found_falls_back_to_line_zero() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test8/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Link to a non-existent anchor let content = "# Index\n\nSee [x](guide.md#nonexistent) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Introduction".to_string(), auto_anchor: "introduction".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } let position = Position { line: 2, character: 15 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should still return a location for unresolved anchor"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.range.start.line, 0, "Should fall back to line 0 when anchor not found" ); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_find_references_from_link_position() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test9/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let other_file = docs_dir.join("faq.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Current file contains a link -- find other links to the same target let content = "# Index\n\nSee [guide](guide.md) for info.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); // Current file links to guide.md (no fragment) let mut current_fi = FileIndex::default(); current_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "".to_string(), line: 3, column: 12, origin: LinkOrigin::Body, }); index.insert_file(current_file.clone(), current_fi); // Other file also links to guide.md (no fragment) let mut other_fi = FileIndex::default(); other_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "".to_string(), line: 7, column: 5, origin: LinkOrigin::Body, }); index.insert_file(other_file.clone(), other_fi); } // Position cursor on the link target "guide.md" in ](guide.md) let position = Position { line: 2, character: 16 }; let result = server.handle_references(¤t_uri, position).await; assert!(result.is_some(), "Should find references when cursor is on a link"); let locations = result.unwrap(); assert_eq!(locations.len(), 2, "Should find both links to guide.md"); let uris: Vec<_> = locations.iter().map(|l| l.uri.clone()).collect(); assert!(uris.contains(&Url::from_file_path(¤t_file).unwrap())); assert!(uris.contains(&Url::from_file_path(&other_file).unwrap())); } #[tokio::test] async fn test_find_references_from_target_file_without_selecting_link() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test9b/docs"); let source_file = docs_dir.join("file-to-link-from.md"); let target_file = docs_dir.join("file-to-link-to.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); // Simulate a target file opened via go-to-definition. Cursor is not on a heading // or link target, but users still expect find-references to discover incoming links. let target_content = "---\ntitle: Heading\n---\n\nTarget file content.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut source_fi = FileIndex::default(); source_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "file-to-link-to.md".to_string(), fragment: "".to_string(), line: 5, column: 24, origin: LinkOrigin::Body, }); index.insert_file(source_file.clone(), source_fi); } // Cursor at top of target file (typical after go-to-definition opens the file) let position = Position { line: 0, character: 0 }; let result = server.handle_references(&target_uri, position).await; assert!( result.is_some(), "Should find incoming file-level references even when cursor is not on a link" ); let locations = result.unwrap(); assert_eq!(locations.len(), 1, "Should find one incoming link"); assert_eq!( locations[0].uri, Url::from_file_path(&source_file).unwrap(), "Reference should point to the linking source file" ); assert_eq!(locations[0].range.start.line, 4); } #[tokio::test] async fn test_goto_definition_link_with_title() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test10/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Link with a title attribute let content = "# Index\n\nSee [guide](guide.md \"The Guide\") for details.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Position cursor on "guide.md" inside `](guide.md "The Guide")` // Line 2: `See [guide](guide.md "The Guide") for details.` let position = Position { line: 2, character: 16 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should resolve link target even with title attribute"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "Should point to guide.md despite title in link" ); assert_eq!(location.range.start.line, 0, "Should target line 0"); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_angle_bracket_link() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test11/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Angle-bracket link target let content = "# Index\n\nSee [guide]() for details.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Position cursor inside `]()` let position = Position { line: 2, character: 16 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should resolve angle-bracket link target"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "Should point to guide.md despite angle brackets" ); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_find_references_includes_same_file_fragment_links() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-nav-test12/docs/readme.md"); let uri = Url::from_file_path(&file).unwrap(); // File with a heading and a same-file fragment link to it let content = "# Installation\n\nSee [above](#installation) for details.\n\nMore text here.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } // Position cursor on the heading (line 0) let position = Position { line: 0, character: 5 }; let result = server.handle_references(&uri, position).await; assert!( result.is_some(), "Should find same-file fragment references to the heading" ); let locations = result.unwrap(); assert_eq!(locations.len(), 1, "Should find the same-file #installation link"); assert_eq!(locations[0].range.start.line, 2, "Reference should be on line 2"); } // ============================================================================= // Navigation: external URL returns None // ============================================================================= #[tokio::test] async fn test_goto_definition_external_url_returns_none() { let server = create_test_server(); let file = test_temp_path("rumdl-nav-url-test/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "See [example](https://example.com) for details.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on "https://example.com" let position = Position { line: 0, character: 18 }; let result = server.handle_goto_definition(&uri, position).await; assert!(result.is_none(), "Should return None for external URLs"); } #[tokio::test] async fn test_goto_definition_mailto_returns_none() { let server = create_test_server(); let file = test_temp_path("rumdl-nav-mailto-test/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "Email [us](mailto:info@example.com) for help.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let position = Position { line: 0, character: 15 }; let result = server.handle_goto_definition(&uri, position).await; assert!(result.is_none(), "Should return None for mailto: links"); } // ============================================================================= // Navigation: reference-style links // ============================================================================= #[tokio::test] async fn test_goto_definition_reference_link() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-ref-test/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Full reference link: [click here][guide] let content = "# Index\n\nSee [click here][guide] for info.\n\n[guide]: guide.md#install\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: Some("install".to_string()), line: 10, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Cursor on "click here" โ€” inside the first bracket pair let position = Position { line: 2, character: 8 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should resolve full reference link"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "Should point to guide.md" ); assert_eq!(location.range.start.line, 9, "Should target the install heading"); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_collapsed_reference() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-collapsed-test/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Collapsed reference: [guide][] let content = "# Index\n\nSee [guide][] for info.\n\n[guide]: guide.md\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Cursor on "guide" in [guide][] let position = Position { line: 2, character: 7 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should resolve collapsed reference link"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!( location.uri, Url::from_file_path(&target_file).unwrap(), "Should point to guide.md" ); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_reference_definition_line() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-refdef-test/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); // Cursor on the reference definition line itself let content = "# Index\n\n[guide]: guide.md#install\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: Some("install".to_string()), line: 10, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Cursor on the definition line let position = Position { line: 2, character: 5 }; let result = server.handle_goto_definition(¤t_uri, position).await; assert!(result.is_some(), "Should navigate from reference definition line"); if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!(location.uri, Url::from_file_path(&target_file).unwrap(),); assert_eq!(location.range.start.line, 9); } else { panic!("Expected Scalar response"); } } #[tokio::test] async fn test_goto_definition_reference_link_external_url() { let server = create_test_server(); let file = test_temp_path("rumdl-nav-ref-ext-test/readme.md"); let uri = Url::from_file_path(&file).unwrap(); // Reference link that resolves to an external URL let content = "See [example] for info.\n\n[example]: https://example.com\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on "example" in [example] let position = Position { line: 0, character: 7 }; let result = server.handle_goto_definition(&uri, position).await; assert!( result.is_none(), "Should return None for reference link resolving to external URL" ); } // ============================================================================= // Narrow range / Zed code_actions_on_format tests // ============================================================================= /// Demonstrates that a narrow range (cursor position) prevents the fixAll action /// from being created, even when fixable warnings exist elsewhere in the document. /// This is the likely root cause for Zed's code_actions_on_format failing: Zed /// sends the cursor position as the range, but fixable_count only counts /// in-range warnings. #[tokio::test] async fn test_fix_all_action_available_regardless_of_range() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); // Line 0: "# Title" -- no fixable issues here // Line 1: "" -- blank line // Line 2: "Tabbed\ttext" -- hard tab (MD010, fixable), mid-line in paragraph // Tab placed mid-line to keep it out of an indented code block position // (column-0 tab after blank line would be skipped with code_blocks=false). let text = "# Title\n\nTabbed\ttext\n"; // Narrow range: only line 0 (where Zed cursor might be) let narrow_range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 0 }, }; let actions = server.get_code_actions(&uri, text, narrow_range).await.unwrap(); let fix_all_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .collect(); // source.fixAll.rumdl counts fixable warnings across the entire document, // so it should appear even when the cursor is on a line without warnings assert!( !fix_all_actions.is_empty(), "fixAll should be created regardless of cursor position when document has fixable issues" ); // Full document range should also have fixAll let full_range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 3, character: 0 }, }; let actions = server.get_code_actions(&uri, text, full_range).await.unwrap(); let fix_all_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .collect(); assert!( !fix_all_actions.is_empty(), "fixAll should be created with full document range" ); } /// Verifies that fixAll fixes ALL document issues, not just those in the requested range. #[tokio::test] async fn test_fix_all_applies_all_document_fixes_regardless_of_range() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); // Two fixable issues on different lines (hard tabs -> MD010). // Tabs placed mid-line in paragraph text to avoid being treated as // indented code blocks (column-0 tab after blank line is skipped with code_blocks=false). // Line 2 (0-indexed LSP line): "First\tissue" // Line 3 (0-indexed LSP line): "Second\tissue" let text = "# Title\n\nFirst\tissue\nSecond\tissue\n"; // Range covering only line 2 (first issue) let partial_range = Range { start: Position { line: 2, character: 0 }, end: Position { line: 2, character: 13 }, }; let actions = server.get_code_actions(&uri, text, partial_range).await.unwrap(); let fix_all_actions: Vec<_> = actions .iter() .filter(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl")) .collect(); // fixAll should be created because there are fixable issues in the document assert!( !fix_all_actions.is_empty(), "fixAll should be created when the document has fixable issues" ); // Verify the fixed content addresses BOTH issues, not just the in-range one let fix_all = &fix_all_actions[0]; let edit = fix_all.edit.as_ref().expect("fixAll should have an edit"); let changes = edit.changes.as_ref().expect("edit should have changes"); let text_edits = changes.get(&uri).expect("changes should include our file"); let fixed_text = &text_edits[0].new_text; assert!( !fixed_text.contains('\t'), "fixAll should fix all tab issues in the document, not just those in range" ); } /// The text the `source.fixAll.rumdl` action writes, or `None` when it is not offered. async fn fix_all_text(server: &RumdlLanguageServer, uri: &Url, text: &str) -> Option { let start = Position { line: 0, character: 0 }; let actions = server .get_code_actions(uri, text, Range { start, end: start }) .await .unwrap(); let fix_all = actions .into_iter() .find(|a| a.kind.as_ref().is_some_and(|k| k.as_str() == "source.fixAll.rumdl"))?; let mut changes = fix_all.edit?.changes?; changes.remove(uri)?.into_iter().next().map(|edit| edit.new_text) } /// A tab (MD010) and a single trailing space (MD009), both fixable by default. const TAB_AND_TRAILING_SPACE: &str = "# Title\n\nFirst\tissue\nTrailing space \n"; /// "Fix all" applies the fixes formatting applies, so a rule configuration marks /// `unfixable` keeps its findings in the document. The rule's quick fix stays on /// offer, since that is one finding the user picks. #[tokio::test] async fn test_fix_all_leaves_unfixable_rules_alone() { let server = create_test_server(); server.rumdl_config.write().await.global.unfixable = vec!["MD010".to_string()]; let uri = Url::parse("file:///test.md").unwrap(); let text = TAB_AND_TRAILING_SPACE; let fixed = fix_all_text(&server, &uri, text) .await .expect("MD009 is still fixable, so fix-all is offered"); assert_eq!(fixed, "# Title\n\nFirst\tissue\nTrailing space\n"); assert_eq!( server.apply_all_fixes(&uri, text).await.unwrap(), Some(fixed), "fix-all and formatting apply the same fixes" ); let tab_line = Range { start: Position { line: 2, character: 0 }, end: Position { line: 2, character: 0 }, }; let actions = server.get_code_actions(&uri, text, tab_line).await.unwrap(); assert!( actions.iter().any(|a| a.kind == Some(CodeActionKind::QUICKFIX) && a.diagnostics .iter() .flatten() .any(|d| d.code == Some(NumberOrString::String("MD010".to_string())))), "the MD010 quick fix should stay on offer, got: {actions:?}" ); } /// A `fixable` allowlist limits fix-all to the rules it names. #[tokio::test] async fn test_fix_all_applies_only_the_fixable_allowlist() { let uri = Url::parse("file:///test.md").unwrap(); let text = TAB_AND_TRAILING_SPACE; let server = create_test_server(); server.rumdl_config.write().await.global.fixable = vec!["MD009".to_string()]; let fixed = fix_all_text(&server, &uri, text) .await .expect("MD009 is allowed to fix"); assert_eq!(fixed, "# Title\n\nFirst\tissue\nTrailing space\n"); assert_eq!(server.apply_all_fixes(&uri, text).await.unwrap(), Some(fixed)); let server = create_test_server(); server.rumdl_config.write().await.global.fixable = vec!["MD010".to_string()]; let fixed = fix_all_text(&server, &uri, text) .await .expect("MD010 is allowed to fix"); assert!( !fixed.contains('\t') && fixed.ends_with("\nTrailing space \n"), "only the tab should be fixed, got: {fixed:?}" ); assert_eq!(server.apply_all_fixes(&uri, text).await.unwrap(), Some(fixed)); } /// A rule's fix capability can follow its settings, and a document can change /// those settings inline. MD033 fixes only with `fix` on, so a document turning /// it on gets those fixes from fix-all, as it does from formatting. #[tokio::test] async fn test_fix_all_reads_fix_capability_from_inline_configuration() { let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "# Title\n\n\n\nSome bold text\n"; let fixed = fix_all_text(&server, &uri, text) .await .expect("MD033 fixes under the inline configuration"); assert!(!fixed.contains(""), "the inline tag should be fixed, got: {fixed:?}"); assert_eq!(server.apply_all_fixes(&uri, text).await.unwrap(), Some(fixed)); } /// Test issue #210: Config cache serves stale config when config file is created or modified /// /// Scenario: /// 1. User opens a project with no .rumdl.toml (default indent=2 for MD007) /// 2. Config cache populates with default config (config_file: None, from_global_fallback: true) /// 3. User creates/updates .rumdl.toml with [MD007] indent=4 /// 4. resolve_config_for_file returns cached default (stale!) instead of new config /// /// Root cause: The cache invalidation in did_change_watched_files only removes entries /// where config_file matches the changed path. Entries with config_file: None (global /// fallback) are never invalidated when a new config file appears. /// /// Additionally, the server only registers file watchers for markdown files, not config /// files, so did_change_watched_files may never fire for .rumdl.toml changes. #[tokio::test] async fn test_config_cache_stale_after_config_file_created() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let project = temp_dir.path().join("project"); fs::create_dir(&project).unwrap(); let test_file = project.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } // Step 1: Resolve config with NO .rumdl.toml present -> should get default (indent=2) let config_before = server.resolve_config_for_file(&test_file).await; let indent_before = crate::config::get_rule_config_value::(&config_before, "MD007", "indent"); // Default MD007 indent is 2 (or None if not in config, which means default applies) assert!( indent_before.is_none() || indent_before == Some(2), "Before config file exists, MD007 indent should be default (2 or absent). Got: {indent_before:?}" ); // Verify cache was populated with fallback entry { let cache = server.config_cache.read().await; let entry = cache .get(&project) .expect("Cache should be populated after first resolve"); assert!( entry.from_global_fallback, "Cache entry should be from global fallback since no config file exists" ); assert!( entry.config_file.is_none(), "Cache entry should have no config_file since it's a global fallback" ); } // Step 2: Create .rumdl.toml with indent=4 let config_path = project.join(".rumdl.toml"); fs::write( &config_path, r#" [MD007] indent = 4 "#, ) .unwrap(); // Step 3: Resolve config again WITHOUT clearing cache // The cache detects that a config file now exists and re-resolves instead of // serving the stale global fallback entry. let config_after = server.resolve_config_for_file(&test_file).await; let indent_after = crate::config::get_rule_config_value::(&config_after, "MD007", "indent"); assert_eq!( indent_after, Some(4), "After .rumdl.toml is created, resolve_config_for_file should pick up the new config. \ Expected MD007 indent=4, got {indent_after:?}" ); // Verify the cache was updated with the new config file entry { let cache = server.config_cache.read().await; let entry = cache.get(&project).expect("Cache entry should exist after re-resolve"); assert!( !entry.from_global_fallback, "Cache entry should no longer be a global fallback after config file was discovered" ); assert!( entry.config_file.is_some(), "Cache entry should reference the newly discovered config file" ); } } /// Test that manually clearing the config cache picks up new config /// /// This verifies the workaround: if the cache is cleared (e.g., via did_change_configuration), /// the new config file is correctly discovered. #[tokio::test] async fn test_config_cache_picks_up_new_config_after_manual_clear() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let project = temp_dir.path().join("project"); fs::create_dir(&project).unwrap(); let test_file = project.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } // Resolve config with no config file -> populates cache with default let config_before = server.resolve_config_for_file(&test_file).await; let indent_before = crate::config::get_rule_config_value::(&config_before, "MD007", "indent"); assert!( indent_before.is_none() || indent_before == Some(2), "Should start with default indent" ); // Create config file let config_path = project.join(".rumdl.toml"); fs::write( &config_path, r#" [MD007] indent = 4 "#, ) .unwrap(); // Manually clear cache (simulates what did_change_configuration does) server.config_cache.write().await.clear(); // Now resolve again - should pick up the new config let config_after = server.resolve_config_for_file(&test_file).await; let indent_after = crate::config::get_rule_config_value::(&config_after, "MD007", "indent"); assert_eq!( indent_after, Some(4), "After cache clear, should pick up new config with indent=4" ); } /// Test that did_change_watched_files retains stale fallback cache entries /// /// When a config file is modified, did_change_watched_files invalidates cache entries /// whose config_file path matches. But entries with config_file=None (global fallback) /// survive, even though a new config file now exists in that directory. #[tokio::test] async fn test_config_cache_retain_logic_misses_fallback_entries() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let project = temp_dir.path().join("project"); fs::create_dir(&project).unwrap(); let test_file = project.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } // Populate cache with fallback entry (no config file) let _ = server.resolve_config_for_file(&test_file).await; // Create config file let config_path = project.join(".rumdl.toml"); fs::write( &config_path, r#" [MD007] indent = 4 "#, ) .unwrap(); // Simulate did_change_watched_files config invalidation logic // This is the retain logic from server.rs lines 844-852 { let mut cache = server.config_cache.write().await; cache.retain(|_, entry| { if let Some(config_file) = &entry.config_file { config_file != &config_path } else { true // BUG: fallback entries (config_file=None) are always retained } }); } // The fallback entry should have been removed, but the retain logic keeps it let cache = server.config_cache.read().await; let entry = cache.get(&project); assert!( entry.is_some(), "BUG: Fallback cache entry survives retain() because config_file is None" ); assert!( entry.unwrap().from_global_fallback, "The surviving entry is the stale global fallback" ); } // โ”€โ”€โ”€ Embedded markdown and code-block-tools integration tests โ”€โ”€โ”€ /// Helper to create a code-block-tools config with rumdl enabled for markdown blocks fn make_embedded_markdown_config() -> crate::code_block_tools::CodeBlockToolsConfig { let lang = crate::code_block_tools::LanguageToolConfig { enabled: true, lint: vec!["rumdl".to_string()], format: Vec::new(), ..Default::default() }; let mut languages = std::collections::BTreeMap::new(); languages.insert("markdown".to_string(), lang); crate::code_block_tools::CodeBlockToolsConfig { enabled: true, languages, ..Default::default() } } #[tokio::test] async fn test_lint_document_embedded_markdown_when_enabled() { let server = create_test_server(); // Enable code-block-tools with rumdl for markdown { let mut cfg = server.rumdl_config.write().await; cfg.code_block_tools = make_embedded_markdown_config(); } let uri = Url::parse("file:///test.md").unwrap(); // The embedded markdown block has no space after the hash (MD018 violation) let text = "# Test\n\n```markdown\n#Hello\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // Should contain a diagnostic from the embedded block (missing heading space on line 4) let embedded_diags: Vec<_> = diagnostics .iter() .filter(|d| { // Line 4 (0-indexed: 3) is the "#Hello" line inside the code block d.range.start.line == 3 }) .collect(); assert!( !embedded_diags.is_empty(), "Expected embedded markdown diagnostics for the heading inside the code block, got none. All diagnostics: {diagnostics:?}" ); } #[tokio::test] async fn test_lint_document_no_embedded_markdown_when_disabled() { let server = create_test_server(); // code_block_tools defaults to disabled let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\n```markdown\n#Hello\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // No diagnostics should come from the embedded block (line 4, 0-indexed: 3) // since code-block-tools is not enabled let embedded_diags: Vec<_> = diagnostics.iter().filter(|d| d.range.start.line == 3).collect(); assert!( embedded_diags.is_empty(), "Expected no embedded markdown diagnostics when code-block-tools is disabled, but got: {embedded_diags:?}" ); } #[tokio::test] async fn test_lint_document_embedded_markdown_empty_block() { let server = create_test_server(); { let mut cfg = server.rumdl_config.write().await; cfg.code_block_tools = make_embedded_markdown_config(); } let uri = Url::parse("file:///test.md").unwrap(); // Empty embedded markdown block should produce no extra diagnostics let text = "# Test\n\n```markdown\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // No diagnostics from the embedded block (it's empty) let embedded_diags: Vec<_> = diagnostics .iter() .filter(|d| d.range.start.line >= 2 && d.range.start.line <= 3) .collect(); assert!( embedded_diags.is_empty(), "Expected no diagnostics from empty embedded markdown block, got: {embedded_diags:?}" ); } #[tokio::test] async fn test_lint_document_multiple_embedded_blocks() { let server = create_test_server(); { let mut cfg = server.rumdl_config.write().await; cfg.code_block_tools = make_embedded_markdown_config(); } let uri = Url::parse("file:///test.md").unwrap(); // Two markdown blocks, each with a missing heading space let text = "# Test\n\n```markdown\n#One\n```\n\n```markdown\n#Two\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // Should have diagnostics from both embedded blocks let block1_diags: Vec<_> = diagnostics .iter() .filter(|d| d.range.start.line == 3) // "#One" is line 4 (0-indexed: 3) .collect(); let block2_diags: Vec<_> = diagnostics .iter() .filter(|d| d.range.start.line == 7) // "#Two" is line 8 (0-indexed: 7) .collect(); assert!( !block1_diags.is_empty(), "Expected diagnostics from first embedded block. All diagnostics: {diagnostics:?}" ); assert!( !block2_diags.is_empty(), "Expected diagnostics from second embedded block. All diagnostics: {diagnostics:?}" ); } #[tokio::test] async fn test_lint_document_embedded_markdown_inside_blockquote() { let server = create_test_server(); { let mut cfg = server.rumdl_config.write().await; cfg.code_block_tools = make_embedded_markdown_config(); } let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\n> ```markdown\n> #Hello\n> ```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); // MD018 starts just past the hash, which sits after the blockquote's "> " let starts: Vec<_> = diagnostics .iter() .filter(|d| d.range.start.line == 3) .map(|d| d.range.start.character) .collect(); assert_eq!(starts, vec![3], "All diagnostics: {diagnostics:?}"); } #[tokio::test] async fn test_lint_document_embedded_markdown_md_alias() { let server = create_test_server(); // Enable for "md" alias instead of "markdown" { let mut cfg = server.rumdl_config.write().await; let mut languages = std::collections::BTreeMap::new(); languages.insert( "md".to_string(), crate::code_block_tools::LanguageToolConfig { enabled: true, lint: vec!["rumdl".to_string()], format: Vec::new(), ..Default::default() }, ); cfg.code_block_tools = crate::code_block_tools::CodeBlockToolsConfig { enabled: true, languages, ..Default::default() }; } let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\n```md\n#Hello\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); let embedded_diags: Vec<_> = diagnostics.iter().filter(|d| d.range.start.line == 3).collect(); assert!( !embedded_diags.is_empty(), "Expected embedded markdown diagnostics for `md` alias. All diagnostics: {diagnostics:?}" ); } // ============================================================================= // find-references fallback: cursor not on heading or link // ============================================================================= /// When cursor is in a target file but not on a heading or link, /// find-references should return all cross-file links pointing to that file. #[tokio::test] async fn test_find_references_fallback_to_file_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test-fallback/docs"); let target_file = docs_dir.join("file-to-link-to.md"); let source_file = docs_dir.join("file-to-link-from.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); // Target file content: cursor on a plain text line (not heading, not link) let content = "---\ntitle: Heading\n---\n\nWe are linking to this file from `file-to-link-from.md`.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Populate workspace index { let mut index = server.workspace_index.write().await; // Target file has no headings relevant to the query let target_fi = FileIndex::default(); index.insert_file(target_file.clone(), target_fi); // Source file links to target file (file-only link, no fragment) let mut source_fi = FileIndex::default(); source_fi.cross_file_links.push(CrossFileLinkIndex { target_path: "file-to-link-to.md".to_string(), fragment: "".to_string(), line: 5, column: 22, origin: LinkOrigin::Body, }); index.insert_file(source_file.clone(), source_fi); } // Cursor on line 4 (0-indexed), plain text - not on a heading or link let position = Position { line: 4, character: 10 }; let result = server.handle_references(&target_uri, position).await; assert!(result.is_some(), "Should find references to the file via fallback"); let locations = result.unwrap(); assert_eq!(locations.len(), 1, "Should find 1 reference from source file"); assert_eq!( locations[0].uri, Url::from_file_path(&source_file).unwrap(), "Reference should come from the source file" ); } /// When cursor is in a file with no incoming references and cursor is not on /// a heading or link, find-references should return None. #[tokio::test] async fn test_find_references_fallback_no_references() { use crate::workspace_index::FileIndex; let server = create_test_server(); let file = test_temp_path("rumdl-nav-test-fallback2/docs/lonely.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "Some text without anything special.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let fi = FileIndex::default(); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_references(&uri, position).await; assert!(result.is_none(), "Should return None when no references exist"); } /// When multiple files link to the same target, the fallback should return all of them. #[tokio::test] async fn test_find_references_fallback_multiple_sources() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test-fallback3/docs"); let target_file = docs_dir.join("target.md"); let source_a = docs_dir.join("a.md"); let source_b = docs_dir.join("b.md"); let source_c = docs_dir.join("c.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "This file is referenced by multiple others.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let target_fi = FileIndex::default(); index.insert_file(target_file.clone(), target_fi); // Three files link to target.md with various fragments for (source, fragment, line) in [(&source_a, "", 2), (&source_b, "section", 5), (&source_c, "", 10)] { let mut fi = FileIndex::default(); fi.cross_file_links.push(CrossFileLinkIndex { target_path: "target.md".to_string(), fragment: fragment.to_string(), line, column: 1, origin: LinkOrigin::Body, }); index.insert_file(source.clone(), fi); } } // Cursor not on heading or link let position = Position { line: 0, character: 5 }; let result = server.handle_references(&target_uri, position).await; assert!(result.is_some(), "Should find references from multiple files"); let locations = result.unwrap(); assert_eq!( locations.len(), 3, "Should find all 3 references regardless of fragment" ); let uris: std::collections::HashSet<_> = locations.iter().map(|l| l.uri.clone()).collect(); assert!(uris.contains(&Url::from_file_path(&source_a).unwrap())); assert!(uris.contains(&Url::from_file_path(&source_b).unwrap())); assert!(uris.contains(&Url::from_file_path(&source_c).unwrap())); } /// When cursor is on a heading, heading-specific references take priority over /// the file-level fallback (ensuring the heading path still works correctly). #[tokio::test] async fn test_find_references_heading_takes_priority_over_fallback() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-nav-test-fallback4/docs"); let target_file = docs_dir.join("guide.md"); let source_with_anchor = docs_dir.join("a.md"); let source_without_anchor = docs_dir.join("b.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "# Installation\n\nHow to install.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); // Source A links to guide.md#installation (matches heading anchor) let mut fi_a = FileIndex::default(); fi_a.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "installation".to_string(), line: 3, column: 5, origin: LinkOrigin::Body, }); index.insert_file(source_with_anchor.clone(), fi_a); // Source B links to guide.md (no anchor - only visible in file-level fallback) let mut fi_b = FileIndex::default(); fi_b.cross_file_links.push(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "".to_string(), line: 7, column: 10, origin: LinkOrigin::Body, }); index.insert_file(source_without_anchor.clone(), fi_b); } // Cursor on heading - should only find anchor-specific references let position = Position { line: 0, character: 5 }; let result = server.handle_references(&target_uri, position).await; assert!(result.is_some(), "Should find heading-specific references"); let locations = result.unwrap(); assert_eq!( locations.len(), 1, "Should only find anchor-matching reference, not file-level" ); assert_eq!( locations[0].uri, Url::from_file_path(&source_with_anchor).unwrap(), "Should find the anchor-specific reference" ); } // ============================================================================= // Hover preview tests // ============================================================================= #[tokio::test] async fn test_hover_inline_link_to_file() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test1/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "# Index\n\nSee [the guide](guide.md) for details.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Add target file content to document cache let target_content = "# Guide\n\nThis is the guide.\n\nIt has multiple lines.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); // Populate workspace index { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Cursor on "guide.md" in `](guide.md)` let position = Position { line: 2, character: 20 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover for file link"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("guide.md"), "Should contain filename"); assert!( markup.value.contains("This is the guide"), "Should contain file content" ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_buffer_uri_resolves_via_workspace_root() { // Issue #647: links in unsaved buffers (non-file:// URIs like `buffer:647`) // must still resolve their hover preview, using the first workspace root as // the base directory for relative link targets. let server = create_test_server(); let workspace = test_temp_path("rumdl-hover-buffer/proj"); let target_file = workspace.join("results.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); // Unsaved buffer: a non-file URI with no on-disk path. let buffer_uri = Url::parse("buffer:647").unwrap(); let content = "# Notes\n\nSee [results](results.md) for details.\n"; server.documents.write().await.insert( buffer_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let target_content = "# Results\n\nThe results are good.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); // Clients like Sublime/VS Code send rootUri/workspaceFolders on initialize. server.workspace_roots.write().await.push(workspace.clone()); // Cursor on "results.md" inside `](results.md)` let position = Position { line: 2, character: 17 }; let result = server.handle_hover(&buffer_uri, position).await; assert!( result.is_some(), "Hover on a buffer-URI link should resolve via the workspace root" ); if let HoverContents::Markup(markup) = result.unwrap().contents { assert!( markup.value.contains("results.md"), "preview should name the target file: {}", markup.value ); assert!( markup.value.contains("The results are good"), "preview should include target content: {}", markup.value ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_buffer_uri_without_workspace_root_returns_none() { // Without any workspace root there is no base directory to resolve a relative // link against, so hover degrades gracefully to None (same as before the fix). let server = create_test_server(); let buffer_uri = Url::parse("buffer:647").unwrap(); let content = "See [x](results.md) here.\n"; server.documents.write().await.insert( buffer_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let position = Position { line: 0, character: 10 }; let result = server.handle_hover(&buffer_uri, position).await; assert!( result.is_none(), "A buffer link with no workspace root has no base dir to resolve against" ); } #[tokio::test] async fn test_hover_non_markdown_file_preview_is_fenced() { // Issue #648: a preview of a non-markdown file is wrapped in a fenced code // block tagged with a language derived from the extension, so editors can // syntax-highlight it. let server = create_test_server(); let dir = test_temp_path("rumdl-hover-fence/proj"); let current_file = dir.join("index.md"); let target_file = dir.join("source.py"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [src](source.py) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let target_content = "import os\n\ndef main():\n pass\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on "source.py" let position = Position { line: 0, character: 13 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return a hover preview for the file link"); if let HoverContents::Markup(markup) = result.unwrap().contents { assert!( markup.value.contains("```python"), "non-markdown preview should open a python code fence: {}", markup.value ); assert!( markup.value.contains("import os"), "preview should include the file content: {}", markup.value ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_markdown_file_preview_not_fenced() { // A markdown target keeps rendering as markdown (no code fence), so headings // and emphasis in the preview render natively. let server = create_test_server(); let dir = test_temp_path("rumdl-hover-md/proj"); let current_file = dir.join("index.md"); let target_file = dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [g](guide.md) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let target_content = "# Guide\n\nSome plain text.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on "guide.md" let position = Position { line: 0, character: 12 }; let result = server.handle_hover(¤t_uri, position).await.unwrap(); if let HoverContents::Markup(markup) = result.contents { assert!( !markup.value.contains("```"), "markdown preview must not be code-fenced: {}", markup.value ); assert!(markup.value.contains("# Guide"), "preview should include the heading"); } else { panic!("Expected Markup hover contents"); } } // Helper: insert current + target documents and return the configured server. async fn setup_line_anchor_hover(link_line: &str, target_content: &str) -> (RumdlLanguageServer, Url) { let server = create_test_server(); let dir = test_temp_path("rumdl-hover-lineanchor/proj"); let current_file = dir.join("index.md"); let target_file = dir.join("sample.py"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: format!("{link_line}\n"), version: Some(1), from_disk: false, }, ); server.documents.write().await.insert( target_uri, DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); (server, current_uri) } #[tokio::test] async fn test_hover_single_line_anchor() { // Issue #648: `#L12` shows the target line with five lines of context on each // side (lines 7-17), fenced with a language hint. let rows = (1..=20).map(|n| format!("row {n:02}")).collect::>().join("\n") + "\n"; let (server, uri) = setup_line_anchor_hover("See [code](sample.py#L12) here.", &rows).await; let position = Position { line: 0, character: 18 }; let result = server.handle_hover(&uri, position).await.unwrap(); if let HoverContents::Markup(markup) = result.contents { let v = &markup.value; assert!(v.contains("```python"), "line preview should be fenced: {v}"); assert!(v.contains("row 07"), "should include 5 lines above (line 7): {v}"); assert!(v.contains("row 12"), "should include the target line: {v}"); assert!(v.contains("row 17"), "should include 5 lines below (line 17): {v}"); assert!(!v.contains("row 06"), "should not include line 6: {v}"); assert!(!v.contains("row 18"), "should not include line 18: {v}"); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_line_range_anchor() { // `#L5-L8` shows exactly that line range. let rows = (1..=20).map(|n| format!("row {n:02}")).collect::>().join("\n") + "\n"; let (server, uri) = setup_line_anchor_hover("See [code](sample.py#L5-L8) here.", &rows).await; let position = Position { line: 0, character: 18 }; let result = server.handle_hover(&uri, position).await.unwrap(); if let HoverContents::Markup(markup) = result.contents { let v = &markup.value; assert!(v.contains("row 05"), "range should include line 5: {v}"); assert!(v.contains("row 08"), "range should include line 8: {v}"); assert!(!v.contains("row 04"), "range should not include line 4: {v}"); assert!(!v.contains("row 09"), "range should not include line 9: {v}"); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_line_anchor_out_of_range() { // A line number past EOF returns a graceful note rather than nothing. let (server, uri) = setup_line_anchor_hover("See [c](sample.py#L99) here.", "one\ntwo\nthree\n").await; let position = Position { line: 0, character: 16 }; let result = server.handle_hover(&uri, position).await; assert!(result.is_some(), "out-of-range line anchor should still return a hover"); if let HoverContents::Markup(markup) = result.unwrap().contents { assert!( markup.value.contains("99"), "note should mention the requested line: {}", markup.value ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_goto_definition_single_line_anchor() { // Issue #738: `#L12` must navigate to line 12 (0-indexed 11), not line 1. let rows = (1..=20).map(|n| format!("row {n:02}")).collect::>().join("\n") + "\n"; let (server, uri) = setup_line_anchor_hover("See [code](sample.py#L12) here.", &rows).await; let position = Position { line: 0, character: 18 }; let result = server.handle_goto_definition(&uri, position).await; if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert!(location.uri.path().ends_with("sample.py")); assert_eq!(location.range.start.line, 11, "#L12 should land on 0-indexed line 11"); } else { panic!("Expected Scalar goto-definition response for a line anchor"); } } #[tokio::test] async fn test_goto_definition_line_range_anchor() { // `#L5-L8` navigates to the start of the range. let rows = (1..=20).map(|n| format!("row {n:02}")).collect::>().join("\n") + "\n"; let (server, uri) = setup_line_anchor_hover("See [code](sample.py#L5-L8) here.", &rows).await; let position = Position { line: 0, character: 18 }; let result = server.handle_goto_definition(&uri, position).await; if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!(location.range.start.line, 4, "#L5-L8 should land on 0-indexed line 4"); } else { panic!("Expected Scalar goto-definition response for a line-range anchor"); } } #[tokio::test] async fn test_goto_definition_lowercase_line_anchor() { // The line-anchor parser is case-insensitive; goto definition must agree. let rows = (1..=20).map(|n| format!("row {n:02}")).collect::>().join("\n") + "\n"; let (server, uri) = setup_line_anchor_hover("See [code](sample.py#l7) here.", &rows).await; let position = Position { line: 0, character: 17 }; let result = server.handle_goto_definition(&uri, position).await; if let Some(GotoDefinitionResponse::Scalar(location)) = result { assert_eq!(location.range.start.line, 6, "#l7 should land on 0-indexed line 6"); } else { panic!("Expected Scalar goto-definition response for a lowercase line anchor"); } } /// The hover preview for `[x](guide.md#a)` when guide.md holds `target_content` /// and the workspace index lists a heading `a` on `line` (1-indexed, the last /// text line of a setext heading). async fn anchor_hover_preview(target_content: &str, line: usize, is_setext: bool) -> String { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-level/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); for (uri, content) in [ (¤t_uri, "# Index\n\nSee [x](guide.md#a) here.\n"), (&target_uri, target_content), ] { server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); } { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "a".to_string(), auto_anchor: "a".to_string(), custom_anchor: None, line, text_lines: 1, is_setext, }); index.insert_file(target_file.clone(), fi); } let hover = server .handle_hover(¤t_uri, Position { line: 2, character: 14 }) .await .expect("hover for an anchor link"); let HoverContents::Markup(markup) = hover.contents else { panic!("Expected markup hover contents"); }; markup.value } #[tokio::test] async fn test_hover_section_ends_at_the_parsed_level_of_a_heading_in_a_container() { // (target document, line of the heading `a`, setext, text the section must // hold, text that starts the next section) let cases: [(&str, usize, bool, &str, &str); 5] = [ // A list item's heading: the line starts with a marker, not a `#`. ( "- ## a\n\nbody\n\n### sub\n\n## next\n\nafter\n", 1, false, "### sub", "## next", ), ( "1. # a\n\nbody\n\n## sub\n\n# next\n\nafter\n", 1, false, "## sub", "# next", ), // A quoted heading. ( "> ## a\n\nbody\n\n### sub\n\n## next\n\nafter\n", 1, false, "### sub", "## next", ), // A quoted setext H1: its underline starts with `>`, not `=`. ( "> a\n> ===\n\nbody\n\n## sub\n\n# next\n\nafter\n", 1, true, "## sub", "# next", ), // A setext H1 opening a list item. ( "- a\n ===\n\nbody\n\n## sub\n\n# next\n\nafter\n", 1, true, "## sub", "# next", ), ]; for (content, line, is_setext, inside, outside) in cases { let preview = anchor_hover_preview(content, line, is_setext).await; assert!(preview.contains("body"), "{content:?}: {preview:?}"); assert!( preview.contains(inside), "{content:?} must show {inside:?}: {preview:?}" ); assert!( !preview.contains(outside), "{content:?} must stop before {outside:?}: {preview:?}" ); } } #[tokio::test] async fn test_hover_section_ends_at_a_quoted_heading() { // (target document, text the section must hold, text that starts the next section) let cases: [(&str, &str, &str); 4] = [ ("## a\n\nbody\n\n### sub\n\n> ## next\n\nafter\n", "### sub", "## next"), ("# a\n\nbody\n\n> # next\n\nafter\n", "body", "# next"), // A quoted heading nested in a list item. ("# a\n\nbody\n\n- > # next\n\nafter\n", "body", "# next"), // A quoted setext heading spanning two text lines ends the section at // its first text line, not at its underline. ("# a\n\nbody\n\n> multi\n> line\n> ===\n\nafter\n", "body", "multi"), ]; for (content, inside, outside) in cases { let preview = anchor_hover_preview(content, 1, false).await; assert!( preview.contains(inside), "{content:?} must show {inside:?}: {preview:?}" ); assert!( !preview.contains(outside), "{content:?} must stop before {outside:?}: {preview:?}" ); } } #[tokio::test] async fn test_hover_without_a_parsed_heading_on_the_indexed_line_has_no_section_end() { // The index is stale: line 1 is no longer a heading. The preview must not // invent a level to stop at, so it runs on to the line limit. let preview = anchor_hover_preview("text\n\n# other\n\nmore\n", 1, false).await; assert!(preview.contains("# other"), "{preview:?}"); assert!(preview.contains("more"), "{preview:?}"); } #[tokio::test] async fn test_hover_inline_link_with_anchor() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test2/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "# Index\n\nSee [install](guide.md#installation) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let target_content = "# Guide\n\nIntro text.\n\n## Installation\n\nRun `cargo install rumdl`.\n\nThen configure.\n\n## Usage\n\nRun it.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Installation".to_string(), auto_anchor: "installation".to_string(), custom_anchor: None, line: 5, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Usage".to_string(), auto_anchor: "usage".to_string(), custom_anchor: None, line: 11, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Cursor on the link target let position = Position { line: 2, character: 18 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover for anchor link"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!( markup.value.contains("## Installation"), "Should contain the heading: got '{}'", markup.value ); assert!( markup.value.contains("cargo install rumdl"), "Should contain section content" ); // Should NOT contain the next heading's content assert!( !markup.value.contains("## Usage"), "Should stop at next heading of equal level" ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_reference_style_link() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test3/docs"); let current_file = docs_dir.join("readme.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [the guide][guide] for details.\n\n[guide]: guide.md\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let target_content = "# Guide\n\nWelcome to the guide.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } // Cursor on "the guide" in [the guide][guide] let position = Position { line: 0, character: 8 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover for reference-style link"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("guide.md"), "Should contain filename"); assert!( markup.value.contains("Welcome to the guide"), "Should contain file content" ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_external_url() { let server = create_test_server(); let file = test_temp_path("rumdl-hover-test4/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "Visit [example](https://example.com) for more.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on "https://example.com" let position = Position { line: 0, character: 18 }; let result = server.handle_hover(&uri, position).await; assert!(result.is_some(), "Should return hover for external URL"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("https://example.com"), "Should show the URL"); assert!(markup.value.contains("External link"), "Should indicate it's external"); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_plain_text_returns_none() { let server = create_test_server(); let file = test_temp_path("rumdl-hover-test5/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "Just some plain text here.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on plain text let position = Position { line: 0, character: 5 }; let result = server.handle_hover(&uri, position).await; assert!(result.is_none(), "Should return None when cursor is not on a link"); } #[tokio::test] async fn test_hover_nonexistent_file_returns_none() { let server = create_test_server(); let file = test_temp_path("rumdl-hover-test6/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "See [missing](nonexistent.md) file.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on the link target let position = Position { line: 0, character: 18 }; let result = server.handle_hover(&uri, position).await; assert!(result.is_none(), "Should return None for link to nonexistent file"); } #[tokio::test] async fn test_hover_same_file_anchor() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-hover-test7/readme.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "# Title\n\nSee [below](#configuration) for config.\n\nSome text.\n\n## Configuration\n\nSet `key = value` in config.\n\nMore config details.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Title".to_string(), auto_anchor: "title".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 7, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } // Cursor on "#configuration" in `](#configuration)` let position = Position { line: 2, character: 16 }; let result = server.handle_hover(&uri, position).await; assert!(result.is_some(), "Should return hover for same-file anchor"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("## Configuration"), "Should contain the heading"); assert!(markup.value.contains("key = value"), "Should contain section content"); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_file_preview_truncates() { use crate::workspace_index::FileIndex; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test8/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("long.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [long file](long.md) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Create a target file with more than 15 lines let long_content: String = (1..=30).fold(String::new(), |mut acc, i| { use std::fmt::Write; let _ = writeln!(acc, "Line {i}"); acc }); server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: long_content.clone(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; index.insert_file(target_file.clone(), FileIndex::default()); } let position = Position { line: 0, character: 18 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover for long file"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("Line 1"), "Should contain first line"); assert!(markup.value.contains("Line 15"), "Should contain line 15"); assert!(!markup.value.contains("Line 16"), "Should not contain line 16"); assert!(markup.value.contains("..."), "Should indicate truncation"); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_anchor_section_end_no_ellipsis() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test9/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [install](guide.md#install) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Target has two sections โ€” "Install" is short, "Usage" follows let target_content = "# Guide\n\n## Install\n\nRun `cargo install`.\n\n## Usage\n\nRun the binary.\n\nMore usage info.\n\nEven more.\n\nAnd more.\n\nAnd more.\n\nAnd more.\n\nAnd more.\n\nAnd more.\n\nAnd more.\n\nAnd more.\n\nAnd more.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Install".to_string(), auto_anchor: "install".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Usage".to_string(), auto_anchor: "usage".to_string(), custom_anchor: None, line: 7, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } let position = Position { line: 0, character: 18 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover for anchor link"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("## Install"), "Should contain the heading"); assert!(markup.value.contains("cargo install"), "Should contain section content"); assert!(!markup.value.contains("## Usage"), "Should stop at next heading"); assert!( !markup.value.contains("..."), "Should NOT show ellipsis when section ended at heading boundary" ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_anchor_preview_skips_code_block_hashes() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test10/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [config](guide.md#configuration) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Target has a code block with `# comment` that looks like a heading let target_content = "## Configuration\n\nExample:\n\n```python\n# This is a Python comment\nconfig = True\n```\n\nMore config info.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } let position = Position { line: 0, character: 18 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!( markup.value.contains("# This is a Python comment"), "Should include code block content (not treat # as heading): got '{}'", markup.value ); assert!( markup.value.contains("More config info"), "Should include content after code block" ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_empty_file() { use crate::workspace_index::FileIndex; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test11/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("empty.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [empty](empty.md) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Empty target file server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: String::new(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; index.insert_file(target_file.clone(), FileIndex::default()); } let position = Position { line: 0, character: 15 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover even for empty file"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("empty.md"), "Should show filename"); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_anchor_does_not_stop_at_hashtag_word() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test12/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [tags](guide.md#tags) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Target has "#hashtag" words that are NOT headings (no space after #) let target_content = "## Tags\n\nUse #markdown and #linting tags.\n\nThey help organize.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Tags".to_string(), auto_anchor: "tags".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } let position = Position { line: 0, character: 15 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!( markup.value.contains("#markdown"), "Should NOT treat #hashtag as a heading and stop: got '{}'", markup.value ); assert!( markup.value.contains("They help organize"), "Should include content after hashtag line" ); } else { panic!("Expected Markup hover contents"); } } #[tokio::test] async fn test_hover_anchor_stops_at_indented_heading() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-hover-test13/docs"); let current_file = docs_dir.join("index.md"); let target_file = docs_dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "See [intro](guide.md#intro) here.\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // CommonMark allows up to 3 spaces of indentation for ATX headings let target_content = "## Intro\n\nSome intro text.\n\n ## Next Section\n\nNext content.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Intro".to_string(), auto_anchor: "intro".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Next Section".to_string(), auto_anchor: "next-section".to_string(), custom_anchor: None, line: 5, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), fi); } let position = Position { line: 0, character: 15 }; let result = server.handle_hover(¤t_uri, position).await; assert!(result.is_some(), "Should return hover"); let hover = result.unwrap(); if let HoverContents::Markup(markup) = hover.contents { assert!(markup.value.contains("Some intro text"), "Should contain intro content"); assert!( !markup.value.contains("Next Section"), "Should stop at indented heading of same level" ); } else { panic!("Expected Markup hover contents"); } } // ========================================================================= // Rename support tests // ========================================================================= #[tokio::test] async fn test_prepare_rename_atx_heading() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test1/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Installation Guide\n\nSome content.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Installation Guide".to_string(), auto_anchor: "installation-guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_prepare_rename(&uri, position).await; assert!(result.is_some(), "Should allow renaming ATX heading"); if let Some(PrepareRenameResponse::Range(range)) = result { // Should cover "Installation Guide" (after "## ") assert_eq!(range.start.line, 0); assert_eq!(range.start.character, 3); // after "## " assert_eq!(range.end.character, 21); // end of "Installation Guide" } else { panic!("Expected Range response"); } } #[tokio::test] async fn test_prepare_rename_setext_heading() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test2/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "Installation Guide\n==================\n\nContent.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Installation Guide".to_string(), auto_anchor: "installation-guide".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: true, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_prepare_rename(&uri, position).await; assert!(result.is_some(), "Should allow renaming Setext heading"); if let Some(PrepareRenameResponse::Range(range)) = result { assert_eq!(range.start.line, 0); assert_eq!(range.start.character, 0); assert_eq!(range.end.character, 18); // "Installation Guide" } else { panic!("Expected Range response"); } } #[tokio::test] async fn test_prepare_rename_keeps_the_marker_of_a_heading_on_a_list_marker_line() { use crate::workspace_index::{FileIndex, HeadingIndex}; // (document, last text line, text lines, setext, expected (start line, start col, end line, end col)) type Case = (&'static str, usize, usize, bool, (u32, u32, u32, u32)); let cases: [Case; 6] = [ ("- a\n ---\n", 1, 1, true, (0, 2, 0, 3)), ("1. a\n ---\n", 1, 1, true, (0, 3, 0, 4)), ("- a\n b\n ---\n", 2, 2, true, (0, 2, 1, 3)), ("- ## a\n", 1, 1, false, (0, 5, 0, 6)), ("> - a\n> ---\n", 1, 1, true, (0, 4, 0, 5)), ("- - ## a ##\n", 1, 1, false, (0, 7, 0, 8)), ]; for (n, (content, line, text_lines, is_setext, expected)) in cases.into_iter().enumerate() { let server = create_test_server(); let file = test_temp_path(&format!("rumdl-rename-marker-{n}/doc.md")); let uri = Url::from_file_path(&file).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: if text_lines == 2 { "a b" } else { "a" }.to_string(), auto_anchor: "a".to_string(), custom_anchor: None, line, text_lines, is_setext, }); index.insert_file(file.clone(), fi); } let position = Position { line: (line - text_lines) as u32, character: 5, }; let Some(PrepareRenameResponse::Range(range)) = server.handle_prepare_rename(&uri, position).await else { panic!("{content:?}: expected a rename range"); }; assert_eq!( ( range.start.line, range.start.character, range.end.line, range.end.character ), expected, "{content:?}: the range must cover the heading text and leave the list marker alone" ); } } #[tokio::test] async fn test_prepare_rename_range_follows_commonmark_atx_whitespace() { use crate::workspace_index::{FileIndex, HeadingIndex}; // CommonMark strips only spaces and tabs around an ATX heading's content and // before its closing sequence. (document, indexed text, expected end column // of the range.) The start column is 2 in every row. let cases: [(&str, &str, u32); 6] = [ // a `#` set off by an em space is text, not a closing sequence ("# a #\u{2003}\n", "a #", 5), // the same with a custom ID after it ("# a #\u{2003} {#id}\n", "a #", 5), // spaces before a real closing sequence are not part of the range ("# a ##\n", "a", 3), // a tab separates the marker from the text ("#\ta\n", "a", 3), // a tab before the closing sequence ("# a\t##\n", "a", 3), // control: a space-separated closing sequence ("# a ##\n", "a", 3), ]; for (n, (content, text, end)) in cases.into_iter().enumerate() { let server = create_test_server(); let file = test_temp_path(&format!("rumdl-rename-ws-{n}/doc.md")); let uri = Url::from_file_path(&file).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: text.to_string(), auto_anchor: "a".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 2 }; let Some(PrepareRenameResponse::Range(range)) = server.handle_prepare_rename(&uri, position).await else { panic!("{content:?}: expected a rename range"); }; assert_eq!( (range.start.character, range.end.character), (2, end), "{content:?}: the range must cover exactly the heading text" ); } } #[tokio::test] async fn test_prepare_rename_not_heading() { let server = create_test_server(); let file = test_temp_path("rumdl-rename-test3/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "Just some text here.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let position = Position { line: 0, character: 5 }; let result = server.handle_prepare_rename(&uri, position).await; assert!(result.is_none(), "Should not allow renaming non-heading text"); } #[tokio::test] async fn test_rename_heading_updates_same_file_links() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test4/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Getting Started\n\nSee [below](#getting-started) for details.\n\nMore [info](#getting-started).\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Getting Started".to_string(), auto_anchor: "getting-started".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&uri, position, "Quick Start").await; assert!(result.is_some(), "Should produce a workspace edit"); let edit = result.unwrap(); let changes = edit.changes.unwrap(); let edits = changes.get(&uri).expect("Should have edits for the document"); // 1 heading rename + 2 link anchor updates assert_eq!(edits.len(), 3, "Should have 3 edits: heading + 2 link anchors"); // Verify heading edit let heading_edit = edits.iter().find(|e| e.range.start.line == 0).unwrap(); assert_eq!(heading_edit.new_text, "Quick Start"); // Verify link anchor edits let link_edits: Vec<_> = edits.iter().filter(|e| e.new_text == "quick-start").collect(); assert_eq!(link_edits.len(), 2, "Should update both link anchors"); } #[tokio::test] async fn test_rename_heading_with_custom_anchor_only_changes_text() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test5/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Guide {#install}\n\nSee [link](#install) for details.\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Guide".to_string(), auto_anchor: "guide".to_string(), custom_anchor: Some("install".to_string()), line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&uri, position, "Tutorial").await; assert!(result.is_some(), "Should produce a workspace edit"); let edit = result.unwrap(); let changes = edit.changes.unwrap(); let edits = changes.get(&uri).expect("Should have edits"); // Only the heading text should change, not the link anchors assert_eq!(edits.len(), 1, "Should only have 1 edit: heading text change"); assert_eq!(edits[0].new_text, "Tutorial"); } #[tokio::test] async fn test_rename_heading_updates_cross_file_links() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-rename-test6/docs"); let target_file = docs_dir.join("guide.md"); let source_file = docs_dir.join("index.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let source_uri = Url::from_file_path(&source_file).unwrap(); let target_content = "## API Reference\n\nAPI docs here.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); let source_content = "See [api](guide.md#api-reference) for details.\n"; server.documents.write().await.insert( source_uri.clone(), DocumentEntry { content: source_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "API Reference".to_string(), auto_anchor: "api-reference".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); let mut source_fi = FileIndex::default(); source_fi.add_cross_file_link(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "api-reference".to_string(), line: 1, column: 11, // byte column of "guide.md" in the link origin: LinkOrigin::Body, }); index.insert_file(source_file.clone(), source_fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&target_uri, position, "REST API").await; assert!(result.is_some(), "Should produce workspace edit"); let edit = result.unwrap(); let changes = edit.changes.unwrap(); // Target file: heading text change let target_edits = changes.get(&target_uri).expect("Should have target edits"); assert!( target_edits.iter().any(|e| e.new_text == "REST API"), "Should rename the heading text" ); // Source file: anchor update let source_edits = changes.get(&source_uri).expect("Should have source edits"); assert!( source_edits.iter().any(|e| e.new_text == "rest-api"), "Should update the cross-file link anchor" ); } /// A query string is not part of a file name, so `guide.md?raw=true` names /// `guide.md`. The index keeps the destination as the document wrote it, which is /// the spelling a link's own text has to be edited through, so navigation has to /// strip the query when it asks which file a link points at. #[tokio::test] async fn test_rename_heading_updates_a_cross_file_link_carrying_a_query() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-rename-test6-query/docs"); let target_file = docs_dir.join("guide.md"); let source_file = docs_dir.join("index.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let source_uri = Url::from_file_path(&source_file).unwrap(); let target_content = "## API Reference\n\nAPI docs here.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); let source_content = "See [api](guide.md?raw=true#api-reference) for details.\n"; server.documents.write().await.insert( source_uri.clone(), DocumentEntry { content: source_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "API Reference".to_string(), auto_anchor: "api-reference".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); let mut source_fi = FileIndex::default(); source_fi.add_cross_file_link(CrossFileLinkIndex { // The spelling production leaves in the index for this link. target_path: "guide.md?raw=true".to_string(), fragment: "api-reference".to_string(), line: 1, column: 11, // byte column of the destination in the link origin: LinkOrigin::Body, }); index.insert_file(source_file.clone(), source_fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&target_uri, position, "REST API").await; assert!(result.is_some(), "Should produce workspace edit"); let edit = result.unwrap(); let changes = edit.changes.unwrap(); let target_edits = changes.get(&target_uri).expect("Should have target edits"); assert!( target_edits.iter().any(|e| e.new_text == "REST API"), "Should rename the heading text" ); let source_edits = changes .get(&source_uri) .expect("a link carrying a query still points at the renamed file"); assert!( source_edits.iter().any(|e| e.new_text == "rest-api"), "Should update the cross-file link anchor" ); } #[tokio::test] async fn test_rename_refuses_empty_name() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test7/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Heading\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Heading".to_string(), auto_anchor: "heading".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&uri, position, "").await; assert!(result.is_none(), "Should refuse empty rename"); let result = server.handle_rename(&uri, position, " ").await; assert!(result.is_none(), "Should refuse whitespace-only rename"); } #[tokio::test] async fn test_rename_refuses_anchor_collision() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test8/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Foo\n\n## Bar\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Foo".to_string(), auto_anchor: "foo".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); fi.add_heading(HeadingIndex { text: "Bar".to_string(), auto_anchor: "bar".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } // Try to rename "Foo" to "Bar" โ€” should be refused due to collision let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&uri, position, "Bar").await; assert!(result.is_none(), "Should refuse rename that causes anchor collision"); } #[tokio::test] async fn test_rename_heading_with_closing_atx() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test9/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Hello ##\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Hello".to_string(), auto_anchor: "hello".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_prepare_rename(&uri, position).await; assert!(result.is_some()); if let Some(PrepareRenameResponse::Range(range)) = result { // Should cover just "Hello", not the trailing "##" assert_eq!(range.start.character, 3); assert_eq!(range.end.character, 8); // "Hello" is 5 chars, starts at 3 } else { panic!("Expected Range response"); } } #[tokio::test] async fn test_rename_updates_same_file_ref_definitions() { use crate::workspace_index::{FileIndex, HeadingIndex}; let server = create_test_server(); let file = test_temp_path("rumdl-rename-test10/doc.md"); let uri = Url::from_file_path(&file).unwrap(); let content = "## Getting Started\n\nSee [ref] for info.\n\n[ref]: #getting-started\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut fi = FileIndex::default(); fi.add_heading(HeadingIndex { text: "Getting Started".to_string(), auto_anchor: "getting-started".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(file.clone(), fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&uri, position, "Quick Start").await; assert!(result.is_some()); let edit = result.unwrap(); let changes = edit.changes.unwrap(); let edits = changes.get(&uri).expect("Should have edits"); // Should have: heading text change + ref definition anchor update // The [ref] usage text doesn't change โ€” it references by label, not by anchor. // Only the definition line `[ref]: #getting-started` needs its anchor updated. let heading_edits: Vec<_> = edits.iter().filter(|e| e.new_text == "Quick Start").collect(); assert_eq!(heading_edits.len(), 1, "Should have 1 heading text edit"); let anchor_edits: Vec<_> = edits.iter().filter(|e| e.new_text == "quick-start").collect(); assert_eq!( anchor_edits.len(), 1, "Should update the reference definition anchor. Got {} edits", anchor_edits.len() ); } #[tokio::test] async fn test_rename_cross_file_multiple_links_same_line() { use crate::workspace_index::{CrossFileLinkIndex, FileIndex, HeadingIndex, LinkOrigin}; let server = create_test_server(); let docs_dir = test_temp_path("rumdl-rename-test11/docs"); let target_file = docs_dir.join("guide.md"); let source_file = docs_dir.join("index.md"); let target_uri = Url::from_file_path(&target_file).unwrap(); let source_uri = Url::from_file_path(&source_file).unwrap(); let target_content = "## Getting Started\n\nContent here.\n"; server.documents.write().await.insert( target_uri.clone(), DocumentEntry { content: target_content.to_string(), version: Some(1), from_disk: false, }, ); // Two links to the same heading on the same line let source_content = "See [a](guide.md#getting-started) and [b](guide.md#getting-started) here.\n"; server.documents.write().await.insert( source_uri.clone(), DocumentEntry { content: source_content.to_string(), version: Some(1), from_disk: false, }, ); { let mut index = server.workspace_index.write().await; let mut target_fi = FileIndex::default(); target_fi.add_heading(HeadingIndex { text: "Getting Started".to_string(), auto_anchor: "getting-started".to_string(), custom_anchor: None, line: 1, text_lines: 1, is_setext: false, }); index.insert_file(target_file.clone(), target_fi); let mut source_fi = FileIndex::default(); // Two cross-file links on the same line source_fi.add_cross_file_link(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "getting-started".to_string(), line: 1, column: 9, origin: LinkOrigin::Body, }); source_fi.add_cross_file_link(CrossFileLinkIndex { target_path: "guide.md".to_string(), fragment: "getting-started".to_string(), line: 1, column: 43, origin: LinkOrigin::Body, }); index.insert_file(source_file.clone(), source_fi); } let position = Position { line: 0, character: 5 }; let result = server.handle_rename(&target_uri, position, "Quick Start").await; assert!(result.is_some()); let edit = result.unwrap(); let changes = edit.changes.unwrap(); // Source file should have 2 anchor edits (one per link), not 1 or duplicates let source_edits = changes.get(&source_uri).expect("Should have source edits"); let anchor_edits: Vec<_> = source_edits.iter().filter(|e| e.new_text == "quick-start").collect(); assert_eq!( anchor_edits.len(), 2, "Should update both cross-file link anchors on the same line" ); // The two edits should have different character positions assert_ne!( anchor_edits[0].range.start.character, anchor_edits[1].range.start.character, "Edits should target different positions on the line" ); } // โ”€โ”€ enable_link_navigation tests โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ #[tokio::test] async fn test_link_navigation_enabled_by_default() { let server = create_test_server(); let config = server.config.read().await; assert!( config.enable_link_navigation, "enable_link_navigation must default to true" ); } #[tokio::test] async fn test_link_navigation_config_deserialization() { // Omitting the field must leave it true (backwards-compatible default) let json = r#"{"enableLinting": true}"#; let config: crate::lsp::types::RumdlLspConfig = serde_json::from_str(json).unwrap(); assert!(config.enable_link_navigation); // Explicitly disabling must be honoured let json = r#"{"enableLinkNavigation": false}"#; let config: crate::lsp::types::RumdlLspConfig = serde_json::from_str(json).unwrap(); assert!(!config.enable_link_navigation); } #[tokio::test] async fn test_hover_disabled_when_link_navigation_off() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///test.md").unwrap(), }, position: Position { line: 0, character: 0 }, }, work_done_progress_params: WorkDoneProgressParams { work_done_token: None }, }; let result = LanguageServer::hover(&server, params).await.unwrap(); assert!( result.is_none(), "hover must return None when enable_link_navigation is false" ); } #[tokio::test] async fn test_goto_definition_disabled_when_link_navigation_off() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = GotoDefinitionParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///test.md").unwrap(), }, position: Position { line: 0, character: 0 }, }, work_done_progress_params: WorkDoneProgressParams { work_done_token: None }, partial_result_params: PartialResultParams { partial_result_token: None, }, }; let result = LanguageServer::goto_definition(&server, params).await.unwrap(); assert!( result.is_none(), "goto_definition must return None when enable_link_navigation is false" ); } #[tokio::test] async fn test_references_disabled_when_link_navigation_off() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = ReferenceParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///test.md").unwrap(), }, position: Position { line: 0, character: 0 }, }, work_done_progress_params: WorkDoneProgressParams { work_done_token: None }, partial_result_params: PartialResultParams { partial_result_token: None, }, context: ReferenceContext { include_declaration: false, }, }; let result = LanguageServer::references(&server, params).await.unwrap(); assert!( result.is_none(), "references must return None when enable_link_navigation is false" ); } #[tokio::test] async fn test_prepare_rename_disabled_when_link_navigation_off() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///test.md").unwrap(), }, position: Position { line: 0, character: 0 }, }; let result = LanguageServer::prepare_rename(&server, params).await.unwrap(); assert!( result.is_none(), "prepare_rename must return None when enable_link_navigation is false" ); } #[tokio::test] async fn test_rename_disabled_when_link_navigation_off() { let server = create_test_server(); server.config.write().await.enable_link_navigation = false; let params = RenameParams { text_document_position: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::parse("file:///test.md").unwrap(), }, position: Position { line: 0, character: 0 }, }, new_name: "new-name".to_string(), work_done_progress_params: WorkDoneProgressParams { work_done_token: None }, }; let result = LanguageServer::rename(&server, params).await.unwrap(); assert!( result.is_none(), "rename must return None when enable_link_navigation is false" ); } /// Verify that when `enableLinkNavigation` is false, the server does not advertise /// hover, definition, references, or rename capabilities during initialization. /// Clients rely on ServerCapabilities to decide whether to send these requests at all; /// returning None from the handlers alone is not sufficient. #[tokio::test] async fn test_initialize_omits_nav_capabilities_when_disabled() { let server = create_test_server(); let options = serde_json::json!({ "enableLinkNavigation": false }); let params = InitializeParams { initialization_options: Some(options), capabilities: ClientCapabilities::default(), ..Default::default() }; let result = LanguageServer::initialize(&server, params).await.unwrap(); let caps = result.capabilities; assert!( caps.hover_provider.is_none(), "hover_provider must be None when enableLinkNavigation is false" ); assert!( caps.definition_provider.is_none(), "definition_provider must be None when enableLinkNavigation is false" ); assert!( caps.references_provider.is_none(), "references_provider must be None when enableLinkNavigation is false" ); assert!( caps.rename_provider.is_none(), "rename_provider must be None when enableLinkNavigation is false" ); } /// Verify that with `enableLinkNavigation` enabled (the default), all four navigation /// capabilities are advertised to the client. #[tokio::test] async fn test_initialize_advertises_nav_capabilities_when_enabled() { let server = create_test_server(); let params = InitializeParams { capabilities: ClientCapabilities::default(), ..Default::default() }; let result = LanguageServer::initialize(&server, params).await.unwrap(); let caps = result.capabilities; assert!( caps.hover_provider.is_some(), "hover_provider must be advertised by default" ); assert!( caps.definition_provider.is_some(), "definition_provider must be advertised by default" ); assert!( caps.references_provider.is_some(), "references_provider must be advertised by default" ); assert!( caps.rename_provider.is_some(), "rename_provider must be advertised by default" ); } #[tokio::test] async fn test_initialize_advertises_symbol_capabilities() { // Symbol providers are a standalone feature, advertised regardless of the // link-navigation flag. let server = create_test_server(); let params = InitializeParams { capabilities: ClientCapabilities::default(), ..Default::default() }; let caps = LanguageServer::initialize(&server, params).await.unwrap().capabilities; assert!( matches!(caps.document_symbol_provider, Some(OneOf::Left(true))), "document_symbol_provider must be advertised: {:?}", caps.document_symbol_provider ); assert!( matches!(caps.workspace_symbol_provider, Some(OneOf::Left(true))), "workspace_symbol_provider must be advertised: {:?}", caps.workspace_symbol_provider ); } // โ”€โ”€ enable_symbols tests โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€ #[tokio::test] async fn test_symbols_enabled_by_default() { let server = create_test_server(); assert!( server.config.read().await.enable_symbols, "enable_symbols must default to true" ); } #[tokio::test] async fn test_symbols_config_deserialization() { // Omitting the field must leave it true (backwards-compatible default) let json = r#"{"enableLinting": true}"#; let config: crate::lsp::types::RumdlLspConfig = serde_json::from_str(json).unwrap(); assert!(config.enable_symbols); // Explicitly disabling must be honoured let json = r#"{"enableSymbols": false}"#; let config: crate::lsp::types::RumdlLspConfig = serde_json::from_str(json).unwrap(); assert!(!config.enable_symbols); } #[tokio::test] async fn test_document_symbol_disabled_when_symbols_off() { // A document WITH headings is open, so the handler would return an outline if // it were unguarded. With symbols disabled it must return None instead. let server = create_test_server(); *server.client_supports_hierarchical_symbols.write().await = true; server.config.write().await.enable_symbols = false; let uri = Url::parse("file:///outline.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "# Top\n\n## Child\n".to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; assert!( server.document_symbol(params).await.unwrap().is_none(), "document_symbol must return None when enable_symbols is false" ); } #[tokio::test] async fn test_workspace_symbol_disabled_when_symbols_off() { use crate::workspace_index::{FileIndex, HeadingIndex, WorkspaceIndex}; // The index has a matching heading, so the handler would return it if it were // unguarded. With symbols disabled it must return None instead. let server = create_test_server(); server.config.write().await.enable_symbols = false; let doc_path = std::env::temp_dir().join("rumdl-ws-symbol-off").join("doc.md"); { let mut index = server.workspace_index.write().await; *index = WorkspaceIndex::new(); let mut fi = FileIndex::default(); fi.headings.push(HeadingIndex { text: "Configuration".to_string(), auto_anchor: "configuration".to_string(), custom_anchor: None, line: 3, text_lines: 1, is_setext: false, }); index.insert_file(doc_path, fi); } let params = WorkspaceSymbolParams { query: "config".to_string(), work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; assert!( server.symbol(params).await.unwrap().is_none(), "workspace symbol must return None when enable_symbols is false" ); } /// When `enableSymbols` is false, the server must not advertise the document or /// workspace symbol capabilities. Clients rely on ServerCapabilities to decide /// whether to send these requests; returning None from the handlers is not enough. #[tokio::test] async fn test_initialize_omits_symbol_capabilities_when_disabled() { let server = create_test_server(); let options = serde_json::json!({ "enableSymbols": false }); let params = InitializeParams { initialization_options: Some(options), capabilities: ClientCapabilities::default(), ..Default::default() }; let caps = LanguageServer::initialize(&server, params).await.unwrap().capabilities; assert!( caps.document_symbol_provider.is_none(), "document_symbol_provider must be None when enableSymbols is false: {:?}", caps.document_symbol_provider ); assert!( caps.workspace_symbol_provider.is_none(), "workspace_symbol_provider must be None when enableSymbols is false: {:?}", caps.workspace_symbol_provider ); } #[tokio::test] async fn test_symbols_disabled_via_did_change_configuration() { let server = create_test_server(); // Default state: symbols are enabled assert!(server.config.read().await.enable_symbols); // A settings payload that only sets enableSymbols: false must be recognized as // a full config and applied (not dropped as an unknown key). server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "enableSymbols": false }), }) .await; assert!( !server.config.read().await.enable_symbols, "did_change_configuration must apply enableSymbols: false" ); // Confirm the handler respects the updated flag, even with a heading present. let uri = Url::parse("file:///live.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "# Heading\n".to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; assert!( server.document_symbol(params).await.unwrap().is_none(), "document_symbol should be suppressed after live config disables symbols" ); } #[tokio::test] async fn test_symbols_reenabled_via_did_change_configuration() { // The live-config path must be symmetric: after disabling symbols, a bare // `{"enableSymbols": true}` payload must re-enable them (key-presence // detection), not be dropped as an unknown key. let server = create_test_server(); *server.client_supports_hierarchical_symbols.write().await = true; server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "enableSymbols": false }), }) .await; assert!(!server.config.read().await.enable_symbols, "disable must apply"); server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "enableSymbols": true }), }) .await; assert!( server.config.read().await.enable_symbols, "did_change_configuration must apply a bare enableSymbols: true re-enable" ); // The handler must respond again once re-enabled. let uri = Url::parse("file:///reenabled.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "# Heading\n".to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentSymbolParams { text_document: TextDocumentIdentifier { uri }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; assert!( server.document_symbol(params).await.unwrap().is_some(), "document_symbol should respond again after symbols are re-enabled" ); } #[tokio::test] async fn test_did_change_configuration_partial_payload_does_not_clobber_other_flags() { // A partial didChangeConfiguration payload must merge onto the current config, // not replace it: setting one flag must leave previously-set flags intact // rather than resetting the omitted fields to their defaults. let server = create_test_server(); // Establish non-default state via one partial payload. server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "enableLinkNavigation": false }), }) .await; assert!( !server.config.read().await.enable_link_navigation, "precondition: enableLinkNavigation disabled" ); // A second, unrelated partial payload must not reset enableLinkNavigation. server .did_change_configuration(DidChangeConfigurationParams { settings: serde_json::json!({ "enableSymbols": false }), }) .await; let config = server.config.read().await; assert!(!config.enable_symbols, "enableSymbols must be applied"); assert!( !config.enable_link_navigation, "a partial enableSymbols payload must NOT clobber the previously-set enableLinkNavigation" ); } #[test] fn test_merge_lsp_config_overlays_only_present_keys() { // A partial payload changes only its keys; every omitted field keeps its // current value (not its default). let current = RumdlLspConfig { enable_link_navigation: false, config_path: Some("/explicit.toml".to_string()), ..RumdlLspConfig::default() }; let merged = merge_lsp_config(¤t, &serde_json::json!({ "enableSymbols": false })) .expect("merge of a valid object payload must succeed"); assert!(!merged.enable_symbols, "the present key is applied"); assert!( !merged.enable_link_navigation, "an omitted bool keeps its current (non-default) value" ); assert_eq!( merged.config_path.as_deref(), Some("/explicit.toml"), "an omitted configPath is preserved, not reset" ); } #[test] fn test_merge_lsp_config_full_snapshot_applies_every_key() { // A full snapshot overlays every field, so it fully applies. let current = RumdlLspConfig { enable_symbols: false, enable_linting: false, ..RumdlLspConfig::default() }; let merged = merge_lsp_config( ¤t, &serde_json::json!({ "enableLinting": true, "enableSymbols": true, "enableLinkNavigation": false }), ) .unwrap(); assert!(merged.enable_linting); assert!(merged.enable_symbols); assert!(!merged.enable_link_navigation); } #[test] fn test_merge_lsp_config_non_object_payload_returns_none() { // The defensive path: a non-object payload yields None so the caller leaves the // config unchanged rather than clobbering it. let current = RumdlLspConfig::default(); assert!(merge_lsp_config(¤t, &serde_json::json!("not an object")).is_none()); assert!(merge_lsp_config(¤t, &serde_json::json!(42)).is_none()); assert!(merge_lsp_config(¤t, &serde_json::Value::Null).is_none()); } #[test] fn test_symbols_config_serde_roundtrip() { // Verify `enableSymbols: false` round-trips correctly through serde let json = r#"{"enableSymbols": false}"#; let config: RumdlLspConfig = serde_json::from_str(json).unwrap(); assert!(!config.enable_symbols, "enableSymbols should deserialize to false"); // All other fields should use their defaults assert!(config.enable_linting, "enableLinting should default to true"); assert!( config.enable_link_navigation, "enableLinkNavigation should default to true" ); // Verify serialization produces camelCase key let serialized = serde_json::to_string(&config).unwrap(); assert!(serialized.contains("\"enableSymbols\":false")); } /// Resolve the config file path that the LSP's per-file resolver picked, /// by calling `resolve_config_for_file` and then inspecting the cache. /// Used by parity tests to compare LSP and CLI resolution on the same tree. async fn lsp_resolve_config_path(server: &RumdlLanguageServer, file: &std::path::Path) -> Option { let _ = server.resolve_config_for_file(file).await; let search_dir = file.parent().unwrap_or(file).to_path_buf(); server .config_cache .read() .await .get(&search_dir) .and_then(|e| e.config_file.clone()) } /// Verifies that the LSP's per-file resolver and the CLI's /// `discover_config_for_dir` pick the same config file on a variety of /// layouts (same filename set, same per-directory precedence, same /// closer-ancestor-wins behaviour across levels, same pyproject.toml /// `[tool.rumdl]` gating). Any future drift between the two paths โ€” the /// class of bug behind rumdl-vscode#115 โ€” will fail this test. #[tokio::test] async fn test_lsp_cli_resolver_parity_on_fixtures() { use crate::config::SourcedConfig; use std::fs; use tempfile::tempdir; struct Fixture { name: &'static str, /// (relative_path, contents); empty contents means "create the file empty" files: &'static [(&'static str, &'static str)], /// Relative path to the markdown file whose directory we resolve from from: &'static str, } let fixtures = &[ Fixture { name: "dotconfig_rumdl_at_root", files: &[(".config/rumdl.toml", "[global]\n"), ("sub/deeper/test.md", "")], from: "sub/deeper/test.md", }, Fixture { name: "rumdl_toml_at_root", files: &[("rumdl.toml", "[global]\n"), ("sub/test.md", "")], from: "sub/test.md", }, Fixture { name: "closer_wins_rumdl_over_dotconfig", files: &[ (".config/rumdl.toml", "[global]\n"), ("sub/rumdl.toml", "[global]\n"), ("sub/deeper/test.md", ""), ], from: "sub/deeper/test.md", }, Fixture { name: "closer_markdownlint_beats_farther_rumdl", files: &[ (".config/rumdl.toml", "[global]\n"), ("sub/.markdownlint.json", "{}"), ("sub/deeper/test.md", ""), ], from: "sub/deeper/test.md", }, Fixture { name: "rumdl_beats_markdownlint_same_dir", files: &[ ("sub/.config/rumdl.toml", "[global]\n"), ("sub/.markdownlint.json", "{}"), ("sub/test.md", ""), ], from: "sub/test.md", }, Fixture { name: "pyproject_without_tool_rumdl_is_skipped", files: &[ ("pyproject.toml", "[tool.black]\nline-length = 100\n"), (".config/rumdl.toml", "[global]\n"), ("sub/test.md", ""), ], from: "sub/test.md", }, Fixture { name: "pyproject_with_tool_rumdl_beats_nothing", files: &[("pyproject.toml", "[tool.rumdl]\n"), ("sub/test.md", "")], from: "sub/test.md", }, // Issue #588: the markdownlint-cli2 config family must be discovered // identically by both resolvers. Before this fixture was added, the // parity test only covered `.markdownlint.json`, so YAML variants // could drift silently. Fixture { name: "markdownlint_cli2_yaml_at_root", files: &[ (".markdownlint-cli2.yaml", "---\nconfig:\n no-inline-html: false\n"), ("sub/test.md", ""), ], from: "sub/test.md", }, Fixture { name: "markdownlint_cli2_jsonc_at_root", files: &[ ( ".markdownlint-cli2.jsonc", "{\n \"config\": { \"no-inline-html\": false }\n}\n", ), ("sub/test.md", ""), ], from: "sub/test.md", }, ]; for fx in fixtures { let temp = tempdir().unwrap(); let project = std::fs::canonicalize(temp.path()).unwrap(); for (rel, contents) in fx.files { let path = project.join(rel); fs::create_dir_all(path.parent().unwrap()).unwrap(); fs::write(&path, contents).unwrap(); } let md_file = project.join(fx.from); let md_dir = md_file.parent().unwrap().to_path_buf(); // CLI resolution let cli_path = SourcedConfig::discover_config_for_dir(&md_dir, &project); // LSP resolution (workspace root = project so walk-up bounds match CLI) let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let lsp_path = lsp_resolve_config_path(&server, &md_file).await; assert_eq!( lsp_path.as_ref().map(|p| std::fs::canonicalize(p).unwrap()), cli_path.as_ref().map(|p| std::fs::canonicalize(p).unwrap()), "LSP and CLI must resolve the same config file for fixture `{}`. \ LSP picked {:?}, CLI picked {:?}", fx.name, lsp_path, cli_path, ); } } /// Regression test for #751: the LSP resolved every discovered config through the /// *explicit*-config entry point, which is standalone by design. That is right for /// a config the user named with `--config`, but a discovered markdownlint config is /// the one case where the CLI keeps the user config as a base, since the /// markdownlint format cannot express rumdl's own settings. The server therefore /// resolved a different config than `rumdl check` on the same file, and reported /// different diagnostics. /// /// Both fixtures compare against the CLI's own result rather than a hardcoded one, /// so the rumdl-native fixture is a live negative control: a fix that merged the /// user config into every discovered config would fail it. /// /// Mutates the process cwd to run the CLI half, so it runs serially. #[tokio::test] #[serial_test::serial] async fn test_lsp_matches_cli_values_under_a_discovered_config() { use crate::config::{Config, SourcedConfig}; use std::fs; use tempfile::tempdir; // (fixture name, project config filename, contents, expected MD007 indent). // MD007 is set only by the user config, so its resolved value is exactly // "was the user config used as a base". let fixtures: &[(&str, &str, &str, Option)] = &[ ( "markdownlint_project_config", ".markdownlint.json", r#"{ "MD004": { "style": "asterisk" } }"#, Some(4), ), ( "markdownlint_cli2_project_config", ".markdownlint-cli2.yaml", "config:\n MD004:\n style: asterisk\n", Some(4), ), ( "rumdl_project_config", ".rumdl.toml", "[MD004]\nstyle = \"asterisk\"\n", None, ), ]; for (name, config_name, config_body, expected_indent) in fixtures { let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); let sub = project.join("sub"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(&sub).unwrap(); fs::create_dir_all(project.join(".git")).unwrap(); // bound both walks here fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( user_config_dir.join("rumdl").join("rumdl.toml"), "[MD007]\nindent = 4\n", ) .unwrap(); fs::write(project.join(config_name), config_body).unwrap(); let md_file = sub.join("test.md"); fs::write(&md_file, "").unwrap(); // CLI resolution: discovery walks up from the process cwd. let prev_cwd = std::env::current_dir().unwrap(); std::env::set_current_dir(&sub).unwrap(); let cli_sourced = SourcedConfig::load_with_discovery_impl(None, None, false, Some(&user_config_dir), Some(&home_dir)); std::env::set_current_dir(&prev_cwd).unwrap(); let cli_config: Config = cli_sourced .expect("CLI config should load") .into_validated_unchecked() .into(); // LSP resolution: its own walk up from the file, workspace root = project. let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let lsp_config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; // Positive control: the markdownlint fixture must actually reach the user // config, or the parity assertion below would hold vacuously. assert_eq!( crate::config::get_rule_config_value::(&cli_config, "MD007", "indent"), *expected_indent, "fixture `{name}`: the CLI itself did not behave as the fixture assumes" ); assert_eq!( crate::config::get_rule_config_value::(&lsp_config, "MD007", "indent"), *expected_indent, "fixture `{name}`: LSP resolved MD007 differently than the CLI" ); assert_eq!( crate::config::get_rule_config_value::(&lsp_config, "MD004", "style"), Some("asterisk".to_string()), "fixture `{name}`: the project config's own settings must still apply" ); assert_eq!( serde_json::to_value(&lsp_config).unwrap(), serde_json::to_value(&cli_config).unwrap(), "fixture `{name}`: LSP and CLI must resolve the same configuration" ); } } /// A broken user config makes a nearer markdownlint config unresolvable, since /// that is the one project config rumdl merges onto the user config. The server /// must not answer with a config from further up the tree: `rumdl check` refuses /// to run at all in this state, so silently substituting the parent's rules would /// have the editor lint against a ruleset that exists nowhere on disk. #[tokio::test] async fn test_resolve_config_does_not_substitute_a_parent_config_when_the_user_config_is_broken() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); let sub = project.join("sub"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(&sub).unwrap(); fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( user_config_dir.join("rumdl").join("rumdl.toml"), "this is not valid toml {{{\n", ) .unwrap(); // A parent config that resolves fine, so substituting it would look like success. fs::write(project.join(".rumdl.toml"), "[MD004]\nstyle = \"dash\"\n").unwrap(); // The nearer config, which needs the broken user config as its base. fs::write( sub.join(".markdownlint.json"), r#"{ "MD004": { "style": "asterisk" } }"#, ) .unwrap(); let md_file = sub.join("test.md"); fs::write(&md_file, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } // Startup discovery runs from the workspace root, where the parent config is // rumdl-native and so resolves standalone. That leaves the parent's rules in // `rumdl_config`, which is the second route by which they could reach this file. { let mut startup = server.rumdl_config.write().await; *startup = crate::config::SourcedConfig::load_with_discovery_impl( Some(&project.join(".rumdl.toml").to_string_lossy()), None, true, Some(&user_config_dir), Some(&home_dir), ) .expect("the parent config resolves standalone") .into_validated_unchecked() .into(); assert_eq!( crate::config::get_rule_config_value::(&startup, "MD004", "style"), Some("dash".to_string()), "precondition: the startup config carries the parent's rules" ); } let config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( crate::config::get_rule_config_value::(&config, "MD004", "style"), None, "resolution should stop at the unresolvable config, not reach for the parent's rules" ); } /// A config that cannot be resolved is a temporary state the user fixes outside the /// workspace, so nothing the server watches changes when they do. Caching it would /// pin the file to defaults for the rest of the session. #[tokio::test] async fn test_resolve_config_retries_after_a_broken_user_config_is_fixed() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); // The unresolvable config sits above the file's own directory, so a cache entry // keyed on that directory would never notice it. let deep = project.join("sub").join("deep"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(&deep).unwrap(); fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); let user_config = user_config_dir.join("rumdl").join("rumdl.toml"); fs::write(&user_config, "this is not valid toml {{{\n").unwrap(); fs::write( project.join("sub").join(".markdownlint.json"), r#"{ "MD004": { "style": "asterisk" } }"#, ) .unwrap(); let md_file = deep.join("test.md"); fs::write(&md_file, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let broken = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( crate::config::get_rule_config_value::(&broken, "MD004", "style"), None, "precondition: the config cannot be resolved while the user config is broken" ); fs::write(&user_config, "[MD007]\nindent = 4\n").unwrap(); let fixed = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( crate::config::get_rule_config_value::(&fixed, "MD004", "style"), Some("asterisk".to_string()), "the config should resolve as soon as the user config parses again" ); } /// Control for the test above: with a valid user config, the same tree resolves to /// the nearer markdownlint config. Without this, the assertion above would also /// pass if the walk never reached that config in the first place. #[tokio::test] async fn test_resolve_config_uses_the_nearer_markdownlint_config_when_the_user_config_loads() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); let sub = project.join("sub"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(&sub).unwrap(); fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( user_config_dir.join("rumdl").join("rumdl.toml"), "[MD007]\nindent = 4\n", ) .unwrap(); fs::write(project.join(".rumdl.toml"), "[MD004]\nstyle = \"dash\"\n").unwrap(); fs::write( sub.join(".markdownlint.json"), r#"{ "MD004": { "style": "asterisk" } }"#, ) .unwrap(); let md_file = sub.join("test.md"); fs::write(&md_file, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( crate::config::get_rule_config_value::(&config, "MD004", "style"), Some("asterisk".to_string()), "the nearer markdownlint config should win over the parent rumdl config" ); assert_eq!( crate::config::get_rule_config_value::(&config, "MD007", "indent"), Some(4), "and it should carry the user config as its base" ); } /// The editor must resolve the same configuration `rumdl check` does, so a /// project that opts into `.editorconfig` gets those settings here too. #[tokio::test] async fn test_resolve_config_applies_editorconfig_when_the_project_opts_in() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(&project).unwrap(); fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(project.join(".rumdl.toml"), "[global]\neditorconfig = true\n").unwrap(); fs::write( project.join(".editorconfig"), "root = true\n[*.md]\nmax_line_length = 111\nindent_size = 4\n", ) .unwrap(); let md_file = project.join("test.md"); fs::write(&md_file, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!(config.global.line_length.get(), 111, "max_line_length should apply"); assert_eq!( crate::config::get_rule_config_value::(&config, "MD007", "indent"), Some(4), "indent_size should apply" ); } /// The config cache is keyed by directory, but `.editorconfig` sections can name /// a single file. Two neighbours must still resolve to their own settings. #[tokio::test] async fn test_resolve_config_applies_editorconfig_sections_per_file() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(&project).unwrap(); fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(project.join(".rumdl.toml"), "[global]\neditorconfig = true\n").unwrap(); fs::write( project.join(".editorconfig"), "root = true\n[narrow.md]\nmax_line_length = 40\n[wide.md]\nmax_line_length = 120\n", ) .unwrap(); let narrow = project.join("narrow.md"); let wide = project.join("wide.md"); fs::write(&narrow, "").unwrap(); fs::write(&wide, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } // Resolve the cached directory entry first, so the second file is answered // from the cache: that is where a per-directory answer would leak. let narrow_config = server .resolve_config_for_file_impl(&narrow, Some(&user_config_dir), Some(&home_dir)) .await; let wide_config = server .resolve_config_for_file_impl(&wide, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!(narrow_config.global.line_length.get(), 40); assert_eq!( wide_config.global.line_length.get(), 120, "a cache hit must not reuse the neighbour's section" ); } /// Build a project whose config opts into `.editorconfig` when asked to, and a /// server that has already resolved the file's config once. #[cfg(test)] async fn server_with_resolved_editorconfig_project(opt_in: bool) -> (tempfile::TempDir, RumdlLanguageServer, PathBuf) { use std::fs; let temp = tempfile::tempdir().unwrap(); let project = temp.path().resolve_like_server(); let rumdl_toml = if opt_in { "[global]\neditorconfig = true\n" } else { "[global]\n" }; fs::write(project.join(".rumdl.toml"), rumdl_toml).unwrap(); fs::write( project.join(".editorconfig"), "root = true\n[*.md]\nmax_line_length = 40\n", ) .unwrap(); let md_file = project.join("doc.md"); fs::write(&md_file, "# Title\n").unwrap(); let server = create_test_server(); server.workspace_roots.write().await.push(project.clone()); server.resolve_config_for_file(&md_file).await; assert!( !server.config_cache.read().await.is_empty(), "the resolved config is what the change under test has to invalidate" ); (temp, server, project) } fn editorconfig_changed(project: &std::path::Path) -> DidChangeWatchedFilesParams { DidChangeWatchedFilesParams { changes: vec![FileEvent { uri: Url::from_file_path(project.join(".editorconfig")).unwrap(), typ: FileChangeType::CHANGED, }], } } /// An `.editorconfig` edit changes what the editor should report, so it has to /// invalidate the cached configs the way any other config file does. #[tokio::test] async fn test_editorconfig_change_invalidates_the_config_cache() { use tower_lsp::LanguageServer; let (_temp, server, project) = server_with_resolved_editorconfig_project(true).await; server.did_change_watched_files(editorconfig_changed(&project)).await; assert!( server.config_cache.read().await.is_empty(), "an opted-in workspace must re-resolve after its .editorconfig changes" ); } /// Without the opt-in the file supplies nothing, so an edit to it cannot change /// a result and must not throw away work. #[tokio::test] async fn test_editorconfig_change_is_ignored_without_the_opt_in() { use tower_lsp::LanguageServer; let (_temp, server, project) = server_with_resolved_editorconfig_project(false).await; server.did_change_watched_files(editorconfig_changed(&project)).await; assert!( !server.config_cache.read().await.is_empty(), "a file rumdl does not read cannot invalidate anything" ); } /// Regression test for rumdl-vscode#115: an opt-in rule enabled via /// `extend-enable` in a `.config/rumdl.toml` at a parent directory must fire /// from the LSP, matching CLI behaviour. /// /// Before the fix, the LSP's walk-up search only looked for `.rumdl.toml`, /// `rumdl.toml`, `pyproject.toml`, `.markdownlint.json` โ€” missing /// `.config/rumdl.toml` โ€” so it fell through to `Config::default()` and /// silently disabled opt-in rules. #[tokio::test] async fn test_resolve_config_finds_dotconfig_rumdl_toml() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); let project = temp_path.join("project"); let dotconfig = project.join(".config"); fs::create_dir_all(&dotconfig).unwrap(); let config_file = dotconfig.join("rumdl.toml"); fs::write( &config_file, r#" [global] extend-enable = ["MD060"] [MD060] style = "aligned" "#, ) .unwrap(); // File nested below the config's parent directory let deep_dir = project.join("sub").join("deeper"); fs::create_dir_all(&deep_dir).unwrap(); let test_file = deep_dir.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let config = server.resolve_config_for_file(&test_file).await; // MD060 must appear in extend_enable so opt-in filtering picks it up assert!( config.global.extend_enable.iter().any(|r| r == "MD060"), "LSP should discover `.config/rumdl.toml` when walking up from a nested file. \ extend_enable was {:?}", config.global.extend_enable ); // And the rule-specific [MD060] table should be loaded assert!( config.rules.contains_key("MD060"), "LSP should load [MD060] table from `.config/rumdl.toml`" ); } /// Regression test for the exact scenario reported in rumdl-vscode#115: /// the LSP server is launched without any workspace folder (single-file /// open in VS Code), its CWD has no config, and the only relevant config /// lives in an ancestor directory as `.config/rumdl.toml`. The resolver /// must still find it by walking up to filesystem root. #[tokio::test] async fn test_resolve_config_no_workspace_finds_dotconfig_rumdl_toml() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); // Canonicalize to avoid `/private/tmp` vs `/tmp` mismatches on macOS when // the resolver walks up through symlink'd parents. let temp_path = std::fs::canonicalize(temp_dir.path()).unwrap(); let project = temp_path.join("project"); let dotconfig = project.join(".config"); fs::create_dir_all(&dotconfig).unwrap(); fs::write( dotconfig.join("rumdl.toml"), r#" [global] extend-enable = ["MD060"] [MD060] style = "aligned" "#, ) .unwrap(); let deep_dir = project.join("sub").join("deeper"); fs::create_dir_all(&deep_dir).unwrap(); let test_file = deep_dir.join("test.md"); fs::write(&test_file, "# Test\n").unwrap(); let server = create_test_server(); // Explicitly leave workspace_roots empty โ€” this is the single-file-open // scenario where VS Code launches the LSP with no workspace folder. assert!(server.workspace_roots.read().await.is_empty()); let config = server.resolve_config_for_file(&test_file).await; assert!( config.global.extend_enable.iter().any(|r| r == "MD060"), "With no workspace root, LSP must still walk up to filesystem root \ and discover `.config/rumdl.toml`. extend_enable was {:?}", config.global.extend_enable ); assert!( config.rules.contains_key("MD060"), "With no workspace root, `[MD060]` table must still load" ); } /// Helper: create a test server with a CLI-supplied config path. fn create_test_server_with_cli_config(cli_config_path: &str) -> RumdlLanguageServer { let path = cli_config_path.to_string(); let (service, _socket) = LspService::new(move |client| RumdlLanguageServer::new(client, Some(&path))); service.inner().clone() } /// Issue #586: `rumdl server --config` must be authoritative for every file, /// overriding any locally-discoverable config that lives alongside the file. /// /// The CLI's `check` command treats an explicit config path as standalone (see /// `src/config/loading.rs` -- "If explicit config path provided -> use ONLY that"). /// The LSP must mirror that contract; otherwise distributing a canonical ruleset /// via `rumdl server --config ` silently fails whenever the user's /// project happens to contain its own config file. #[tokio::test] async fn test_cli_config_overrides_local_project_config() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let temp_path = temp_dir.path(); // The user's project has its own .rumdl.toml -- this MUST be ignored // when the server was started with --config pointing elsewhere. let project = temp_path.join("user_project"); fs::create_dir(&project).unwrap(); fs::write( project.join(".rumdl.toml"), r#" [global] [MD013] line_length = 50 "#, ) .unwrap(); // The CLI-supplied config (e.g. shipped with a Claude Code plugin). let cli_config = temp_path.join("plugin").join(".rumdl.toml"); fs::create_dir_all(cli_config.parent().unwrap()).unwrap(); fs::write( &cli_config, r#" [global] [MD013] line_length = 200 "#, ) .unwrap(); let server = create_test_server_with_cli_config(cli_config.to_str().unwrap()); server.load_configuration(false).await; { let mut roots = server.workspace_roots.write().await; roots.push(project.clone()); } let test_file = project.join("doc.md"); fs::write(&test_file, "# Test\n").unwrap(); let resolved = server.resolve_config_for_file(&test_file).await; let line_length = crate::config::get_rule_config_value::(&resolved, "MD013", "line_length"); assert_eq!( line_length, Some(200), "Issue #586: explicit --config must win over a locally-discoverable .rumdl.toml. \ Got line_length={line_length:?} (expected 200 from CLI config, not 50 from project)." ); } /// Issue #586 (related): the CLI-supplied config path must survive a client /// `initialize` that wholesale-replaces `self.config`. Many editors send /// initialization options without a `configPath`, and the existing implementation /// dropped the CLI value when that happened. #[tokio::test] async fn test_cli_config_survives_init_options_without_config_path() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let cli_config = temp_dir.path().join("cli.toml"); fs::write( &cli_config, r#" [global] [MD013] line_length = 175 "#, ) .unwrap(); let server = create_test_server_with_cli_config(cli_config.to_str().unwrap()); // Simulate `initialize` receiving init options that do NOT specify a // configPath -- the existing implementation overwrites self.config // wholesale (see src/lsp/server.rs::initialize). { let mut config = server.config.write().await; *config = RumdlLspConfig { config_path: None, enable_auto_fix: true, ..RumdlLspConfig::default() }; } server.load_configuration(false).await; let project = temp_dir.path().join("project"); fs::create_dir(&project).unwrap(); let file = project.join("doc.md"); fs::write(&file, "# Test\n").unwrap(); let resolved = server.resolve_config_for_file(&file).await; let line_length = crate::config::get_rule_config_value::(&resolved, "MD013", "line_length"); assert_eq!( line_length, Some(175), "Issue #586: client init options without configPath must not erase the CLI --config. \ Got line_length={line_length:?} (expected 175 from CLI config)." ); } /// Issue #586 (regression guard surfaced by code review): when the client changes /// `configPath` at runtime via `workspace/didChangeConfiguration`, the in-memory /// `rumdl_config` must be reloaded from the new file. Without this, the explicit-config /// fast path in `resolve_config_for_file` keeps returning the previously-loaded config /// and the client's setting change is silently ignored. #[tokio::test] async fn test_runtime_config_path_change_reloads_config() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let initial_config = temp_dir.path().join("initial.toml"); fs::write( &initial_config, r#" [global] [MD013] line_length = 60 "#, ) .unwrap(); let updated_config = temp_dir.path().join("updated.toml"); fs::write( &updated_config, r#" [global] [MD013] line_length = 240 "#, ) .unwrap(); let server = create_test_server(); // Simulate client `initialize` setting an initial configPath. { let mut config = server.config.write().await; *config = RumdlLspConfig { config_path: Some(initial_config.to_string_lossy().to_string()), ..RumdlLspConfig::default() }; } server.load_configuration(false).await; // Sanity: the initial config is in effect. let project = temp_dir.path().join("project"); fs::create_dir(&project).unwrap(); let file = project.join("doc.md"); fs::write(&file, "# Test\n").unwrap(); let resolved = server.resolve_config_for_file(&file).await; assert_eq!( crate::config::get_rule_config_value::(&resolved, "MD013", "line_length"), Some(60), "Initial configPath should be in effect." ); // Simulate the client switching configPath via did_change_configuration. let new_settings = serde_json::json!({ "rumdl": { "configPath": updated_config.to_string_lossy().to_string() } }); server .did_change_configuration(tower_lsp::lsp_types::DidChangeConfigurationParams { settings: new_settings }) .await; let resolved = server.resolve_config_for_file(&file).await; assert_eq!( crate::config::get_rule_config_value::(&resolved, "MD013", "line_length"), Some(240), "Issue #586 (P1): runtime configPath change must reload the config; fast-path must not \ return the stale rumdl_config from the previous configPath." ); } /// Issue #586 (precedence): when both `rumdl server --config` and a client-supplied /// `configPath` are present, the CLI flag wins. The user's stated rationale -- shipping /// a canonical ruleset alongside a plugin -- requires this; otherwise the editor /// can silently override the distributed config. #[tokio::test] async fn test_cli_config_overrides_client_init_config_path() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().unwrap(); let cli_config = temp_dir.path().join("cli.toml"); fs::write( &cli_config, r#" [global] [MD013] line_length = 220 "#, ) .unwrap(); let client_config = temp_dir.path().join("client.toml"); fs::write( &client_config, r#" [global] [MD013] line_length = 40 "#, ) .unwrap(); let server = create_test_server_with_cli_config(cli_config.to_str().unwrap()); // Simulate the client passing its own configPath via init options. { let mut config = server.config.write().await; *config = RumdlLspConfig { config_path: Some(client_config.to_string_lossy().to_string()), ..RumdlLspConfig::default() }; } server.load_configuration(false).await; let project = temp_dir.path().join("project"); fs::create_dir(&project).unwrap(); let file = project.join("doc.md"); fs::write(&file, "# Test\n").unwrap(); let resolved = server.resolve_config_for_file(&file).await; let line_length = crate::config::get_rule_config_value::(&resolved, "MD013", "line_length"); assert_eq!( line_length, Some(220), "Issue #586: --config must outrank client init configPath. \ Got line_length={line_length:?} (expected 220 from CLI config, not 40 from client)." ); } /// Regression test for issue #588: `rumdl server` (LSP) must honour /// alias-based disable lists in `.markdownlint-cli2.yaml`. /// /// The reporter saw `MD033` violations from the LSP for a file containing /// `...`, even though the project's `.markdownlint-cli2.yaml` set /// `no-inline-html: false`. The CLI honoured the same config. /// /// Root cause: the markdownlint parser pushed the alias (`"no-inline-html"`) /// into `global.disable`, and `rules::filter_rules` matched against /// `Rule::name()` (`"MD033"`) with plain string equality. The CLI compensated /// by canonicalising at filter time; the LSP did not, causing silent /// divergence. /// /// The fix establishes an invariant โ€” every `Config` returned from a /// mutation boundary has canonical rule IDs in its rule lists โ€” enforced /// by `Config::canonicalize_rule_lists` in `From for Config`, /// LSP `apply_lsp_settings_*`, and WASM `to_config_with_warnings`. /// /// This test asserts both halves of the parity contract: /// 1. `MD033` is filtered out of the LSP's enabled rule set. /// 2. The LSP produces no `MD033` diagnostics for the reporter's exact /// reproduction file. #[tokio::test] async fn test_issue_588_lsp_honours_markdownlint_cli2_alias_disable() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().expect("create temp dir"); let project = temp_dir.path().resolve_like_server(); fs::write( project.join(".markdownlint-cli2.yaml"), "---\nconfig:\n no-inline-html: false\n", ) .expect("write .markdownlint-cli2.yaml"); // Reporter's exact reproduction file (frontmatter + inline HTML). let test_md = project.join("test.md"); let content = "---\ntitle: Heading\n---\n\nTest Markdown1.\n"; fs::write(&test_md, content).expect("write test.md"); let server = create_test_server(); server.workspace_roots.write().await.push(project.clone()); let resolved_config = server.resolve_config_for_file(&test_md).await; // Invariant: alias was canonicalised to "MD033" in the disable list. assert!( resolved_config.global.disable.iter().any(|r| r == "MD033"), "Issue #588: alias-based disable in .markdownlint-cli2.yaml must be canonicalised \ to MD033 in the resolved Config. Got disable list: {:?}", resolved_config.global.disable, ); assert!( !resolved_config.global.disable.iter().any(|r| r == "no-inline-html"), "Issue #588: the alias \"no-inline-html\" must NOT remain in the disable list \ after canonicalisation. Got disable list: {:?}", resolved_config.global.disable, ); // Filter rules through the same path the LSP uses; MD033 must be excluded. let all_rules = crate::rules::all_rules(&resolved_config); let filtered_rules = crate::rules::filter_rules(&all_rules, &resolved_config.global); assert!( !filtered_rules.iter().any(|r| r.name() == "MD033"), "Issue #588: MD033 must be filtered out when .markdownlint-cli2.yaml sets \ no-inline-html: false. Filtered rule names: {:?}", filtered_rules.iter().map(|r| r.name()).collect::>(), ); // End-to-end: lint_document must produce no MD033 diagnostics. let uri = Url::from_file_path(&test_md).unwrap(); let diagnostics = server.lint_document(&uri, content, true).await.unwrap(); let md033_diagnostics: Vec<_> = diagnostics .iter() .filter(|d| { d.code .as_ref() .is_some_and(|c| matches!(c, NumberOrString::String(s) if s == "MD033")) }) .collect(); assert!( md033_diagnostics.is_empty(), "Issue #588: LSP must emit no MD033 diagnostics for the reporter's reproduction. \ Got {} diagnostic(s): {:?}", md033_diagnostics.len(), md033_diagnostics .iter() .map(|d| format!("line {}: {}", d.range.start.line, d.message)) .collect::>(), ); } /// Companion to `test_issue_588_lsp_honours_markdownlint_cli2_alias_disable`: /// the same invariant must hold when a user writes aliases directly in /// `.rumdl.toml` (`disable = ["line-length"]`). Before the canonical-IDs /// invariant, this also silently failed for non-CLI consumers. #[tokio::test] async fn test_alias_in_rumdl_toml_disable_is_canonicalized() { use std::fs; use tempfile::tempdir; let temp_dir = tempdir().expect("create temp dir"); let project = temp_dir.path().resolve_like_server(); fs::write( project.join(".rumdl.toml"), "[global]\ndisable = [\"line-length\", \"no-inline-html\"]\n", ) .expect("write .rumdl.toml"); let test_md = project.join("test.md"); fs::write(&test_md, "# Title\n").expect("write test.md"); let server = create_test_server(); server.workspace_roots.write().await.push(project.clone()); let resolved = server.resolve_config_for_file(&test_md).await; assert!( resolved.global.disable.iter().any(|r| r == "MD013"), "Alias `line-length` in .rumdl.toml must be canonicalised to MD013. Got: {:?}", resolved.global.disable, ); assert!( resolved.global.disable.iter().any(|r| r == "MD033"), "Alias `no-inline-html` in .rumdl.toml must be canonicalised to MD033. Got: {:?}", resolved.global.disable, ); assert!( !resolved .global .disable .iter() .any(|r| r == "line-length" || r == "no-inline-html"), "Aliases must not remain in the disable list after canonicalisation. Got: {:?}", resolved.global.disable, ); let all_rules = crate::rules::all_rules(&resolved); let filtered = crate::rules::filter_rules(&all_rules, &resolved.global); assert!( !filtered.iter().any(|r| r.name() == "MD013" || r.name() == "MD033"), "filter_rules must exclude MD013 and MD033 when their aliases are in disable. \ Got: {:?}", filtered.iter().map(|r| r.name()).collect::>(), ); } #[test] fn test_lsp_config_walk_stops_at_home_boundary() { // A config file in $HOME is user-level, not a project config. When the linted file // lives in a config-less directory under $HOME and no workspace root bounds the walk // (single-file edit), the upward project-config search must NOT return ~/.rumdl.toml. // Otherwise it shadows the platform user-config dir, which is exactly the precedence // inversion reported on Windows (%HOMEPATH%\.rumdl.toml beating %APPDATA%\rumdl). use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let fake_home = temp.path().join("home"); let work_dir = fake_home.join("notes").join("subdir"); fs::create_dir_all(&work_dir).unwrap(); fs::write(fake_home.join(".rumdl.toml"), "[global]\ndisable = [\"MD041\"]\n").unwrap(); let candidates = crate::config::collect_project_config_candidates(&work_dir, None, Some(&fake_home)); assert!( candidates.is_empty(), "Home dotfile must not be discovered as a project config, got: {candidates:?}" ); } #[test] fn test_lsp_config_walk_finds_project_config_below_home() { // The home boundary must not suppress a genuine project config that lives in a // subdirectory of $HOME -- only $HOME itself is off-limits as a project root. use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let fake_home = temp.path().join("home"); let project = fake_home.join("project"); let nested = project.join("docs"); fs::create_dir_all(&nested).unwrap(); fs::write(project.join(".rumdl.toml"), "[global]\ndisable = [\"MD013\"]\n").unwrap(); let candidates = crate::config::collect_project_config_candidates(&nested, None, Some(&fake_home)); assert_eq!( candidates.first(), Some(&project.join(".rumdl.toml")), "A real project config below $HOME must still be discovered" ); } #[test] fn test_lsp_config_walk_collects_same_dir_fallback_candidates() { // Within a directory, every config file is collected in precedence order so the // caller can fall through to a lower-precedence file when a higher-precedence one // fails to load. Without this, a stale/malformed `.rumdl.toml` would hide a valid // markdownlint config sitting next to it. use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let dir = temp.path().join("proj"); fs::create_dir_all(&dir).unwrap(); fs::write(dir.join(".rumdl.toml"), "[global]\ndisable = [\"MD013\"]\n").unwrap(); fs::write(dir.join(".markdownlint.json"), "{}\n").unwrap(); // Bound the walk to this directory (workspace root) so only its own files are scanned. let candidates = crate::config::collect_project_config_candidates(&dir, Some(&dir), None); assert_eq!( candidates, vec![dir.join(".rumdl.toml"), dir.join(".markdownlint.json")], "both same-directory config files must be collected in precedence order" ); } #[tokio::test] async fn test_apply_all_fixes_matches_cli_fix_engine() { // apply_all_fixes routes through the FixCoordinator, so editor fix-all // must produce byte-identical output to the CLI fix engine for the same // content and config, including cascading fixes that need more than one // pass (a single-pass loop would leave residue here). let server = create_test_server(); let uri = Url::parse("file:///test.md").unwrap(); let text = "#Title \nSome text \n- item\n- item2\n## Sub##\nmore text"; let lsp_fixed = server .apply_all_fixes(&uri, text) .await .unwrap() .expect("content has fixable violations"); let config = crate::config::Config::default(); let all_rules = crate::rules::all_rules(&config); let rules = crate::rules::filter_rules(&all_rules, &config.global); let mut cli_fixed = text.to_string(); crate::fix_coordinator::FixCoordinator::new() .apply_fixes_iterative(&rules, &[], &mut cli_fixed, &config, 100, None) .expect("CLI fix engine must converge"); assert_eq!(lsp_fixed, cli_fixed, "editor fix-all must match the CLI fix engine"); assert_ne!(lsp_fixed, text, "the test content must actually change"); } /// Editor fix-all must hand back the document in its own line-ending /// convention. `rumdl fmt` normalises a file to LF before fixing and restores /// the original ending on write; the LSP used to pass the editor's text to the /// fix engine as-is, so a rule whose `fix()` rebuilds the document with /// `join("\n")` (MD032 here) returned a CRLF document as LF, and the /// whole-document edit then rewrote every line ending in the buffer. #[tokio::test] async fn test_apply_all_fixes_keeps_the_documents_line_endings() { let server = create_test_server(); let uri = Url::parse("file:///crlf.md").unwrap(); let lf = "# Title\n\nText\n- item\n"; let crlf = lf.replace('\n', "\r\n"); let lf_fixed = server .apply_all_fixes(&uri, lf) .await .unwrap() .expect("MD032 must fix the LF document"); // Control: the fix ran and rebuilt the document (a blank line before the list). assert_eq!(lf_fixed, "# Title\n\nText\n\n- item\n"); let crlf_fixed = server .apply_all_fixes(&uri, &crlf) .await .unwrap() .expect("MD032 must fix the CRLF document"); assert_eq!( crlf_fixed, lf_fixed.replace('\n', "\r\n"), "the CRLF document must come back as the LF result with its endings restored" ); // A CRLF document with nothing to fix must not be reported as changed. let clean_crlf = "# Title\r\n\r\nText\r\n\r\n- item\r\n"; assert_eq!(server.apply_all_fixes(&uri, clean_crlf).await.unwrap(), None); } /// A buffer with mixed endings keeps each untouched line's ending through /// both formatting phases; a line the fixes insert takes the ending of the /// line it follows, which is what `rumdl fmt` writes for the same file. #[tokio::test] async fn test_formatting_keeps_each_line_ending_of_a_mixed_document() { let server = create_test_server(); let uri = Url::parse("file:///format-mixed.md").unwrap(); let fixed = server .apply_all_fixes(&uri, "# Title\r\nText\n- item\r\n") .await .unwrap() .expect("MD022 and MD032 must fix the mixed document"); assert_eq!(fixed, "# Title\r\n\r\nText\n\n- item\r\n"); let formatted = RumdlLanguageServer::apply_formatting_options( "Text \nmore \r\nend\n\n\n".to_string(), &editor_formatting_options(), crate::config::MarkdownFlavor::Standard, ); assert_eq!(formatted, "Text\nmore\r\nend\n"); } /// "Format Document" on a CRLF buffer must keep it CRLF through both phases: /// the rule fixes and the editor's formatting options. #[tokio::test] async fn test_formatting_keeps_crlf_line_endings() { let server = create_test_server(); let uri = Url::parse("file:///format-crlf.md").unwrap(); let input = "# Title \r\n\r\nText\r\n- item\r\n\r\n\r\n"; let (after_first, after_second) = format_twice(&server, &uri, input).await; assert_eq!(after_first, "# Title\r\n\r\nText\r\n\r\n- item\r\n"); assert_eq!( after_first, after_second, "formatting must reach a fixpoint in one pass" ); } /// A single quick fix copies the rule's replacement into a `TextEdit`. On a /// CRLF buffer a fix that inserts a line ending (MD022 and MD032 here, and /// MD047 at the end) used to insert a bare `\n`, leaving the buffer with mixed /// endings after the very edit meant to clean it up. #[tokio::test] async fn test_quick_fix_edits_use_the_documents_crlf_line_ending() { let server = create_test_server(); let uri = Url::parse("file:///quick-fix-crlf.md").unwrap(); let text = "# Title\r\nText\r\n- item\r\ntext"; let range = Range { start: Position { line: 0, character: 0 }, end: Position { line: 3, character: 4 }, }; let actions = server.get_code_actions(&uri, text, range).await.unwrap(); let new_texts: Vec = actions .iter() .filter_map(|action| action.edit.as_ref()) .filter_map(|edit| edit.changes.as_ref()) .flat_map(|changes| changes.values().flatten()) .map(|edit| edit.new_text.clone()) .collect(); let has_bare_lf = |text: &str| { let bytes = text.as_bytes(); bytes .iter() .enumerate() .any(|(i, b)| *b == b'\n' && (i == 0 || bytes[i - 1] != b'\r')) }; let bare: Vec<_> = new_texts.iter().filter(|t| has_bare_lf(t)).collect(); assert!( bare.is_empty(), "quick fix inserted a bare LF into a CRLF buffer: {bare:?}" ); // Control: line-inserting quick fixes were offered at all. assert!( new_texts.iter().filter(|t| t.contains("\r\n")).count() >= 3, "expected MD022, MD032 and MD047 quick fixes inserting CRLF; got {new_texts:?}" ); } /// Regression test for rumdl-intellij#2: a multi-line diagnostic's quick fixes /// must be offered on every line the diagnostic spans, not only the warning's /// anchor (first) line. IntelliJ requests code actions for the cursor's line, so /// with the bug a user whose cursor sat on a later line of a flagged paragraph /// saw an empty light-bulb popup even though the squiggle covered that line. #[tokio::test] async fn test_code_action_offered_across_multiline_diagnostic_span() { use tempfile::tempdir; let server = create_test_server(); let temp_dir = tempdir().expect("Failed to create temp dir"); std::fs::write( temp_dir.path().join("pyproject.toml"), r#" [tool.rumdl] flavor = "mkdocs" line_length = 120 [tool.rumdl.MD013] reflow = true reflow-mode = "semantic-line-breaks" "#, ) .unwrap(); // One paragraph across three physical lines holding two sentences; in // semantic-line-breaks mode rumdl flags the whole paragraph (0-indexed // lines 2..=4) with a single MD013 warning anchored at line 2. let content = "# Title\n\nBefore creating a task and sending it to the background, validate that all\nrequired resources exist. We want to fail early if we now, that e.g a\nworkbook with a passed `workbook_id` does not exist.\n"; let test_md_path = temp_dir.path().join("test.md"); std::fs::write(&test_md_path, content).unwrap(); let canonical_temp = temp_dir.path().resolve_like_server(); server.workspace_roots.write().await.push(canonical_temp); let canonical_test_path = test_md_path.resolve_like_server(); let uri = Url::from_file_path(&canonical_test_path).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); // Cursor on the LAST line of the flagged paragraph (0-indexed line 4) must // still surface the MD013 reflow quick fix, not just the document-wide // "Fix all" source action. let range = Range { start: Position { line: 4, character: 0 }, end: Position { line: 4, character: 0 }, }; let actions = server.get_code_actions(&uri, content, range).await.unwrap(); assert!( actions.iter().any(|a| a.title.contains("semantic line breaks")), "MD013 reflow quick fix must be offered on the last line of the flagged paragraph, got: {:?}", actions.iter().map(|a| &a.title).collect::>() ); } /// Apply one LSP `formatting` pass and return the resulting document content, /// persisting it back to the server (mimicking the editor applying the edit). /// The handler returns a single whole-document edit, so `new_text` is the full /// new content. async fn format_once(server: &RumdlLanguageServer, uri: &Url, options: &FormattingOptions) -> String { let before = server.documents.read().await.get(uri).unwrap().content.clone(); let params = DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: options.clone(), work_done_progress_params: WorkDoneProgressParams::default(), }; let after = match server.formatting(params).await.unwrap() { Some(edits) if !edits.is_empty() => edits[0].new_text.clone(), _ => before, }; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: after.clone(), version: Some(1), from_disk: false, }, ); after } /// Standard editor formatting options used by the formatting tests. fn editor_formatting_options() -> FormattingOptions { FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), } } /// Build a test server whose resolved config sets MD030 `ul-single`/`ul-multi`, /// using the same config representation the CLI loads from a `rumdl.toml`. async fn server_with_md030_spacing(ul_single: usize, ul_multi: usize) -> RumdlLanguageServer { let server = create_test_server(); let mut config = crate::config::Config::default(); let toml_src = format!("[MD030]\nul-single = {ul_single}\nul-multi = {ul_multi}\n"); let parsed: toml::Table = toml::from_str(&toml_src).unwrap(); for (key, value) in parsed { let mut values = std::collections::BTreeMap::new(); if let toml::Value::Table(table) = value { for (k, v) in table { values.insert(k, v); } } config .rules .insert(key, crate::config::RuleConfig { severity: None, values }); } *server.rumdl_config.write().await = config; // Force config resolution to use the injected config instead of on-disk discovery. server.config.write().await.config_path = Some("rumdl.toml".to_string()); server } /// Store `content` under `uri`, format it twice, and return both results so the /// caller can assert the formatting handler reaches a fixpoint in a single pass. async fn format_twice(server: &RumdlLanguageServer, uri: &Url, content: &str) -> (String, String) { server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let options = editor_formatting_options(); let first = format_once(server, uri, &options).await; let second = format_once(server, uri, &options).await; (first, second) } /// Regression for rvben/rumdl-vscode#145: a single "Format Document" must reach a /// fixpoint. Nested lists whose marker spacing AND continuation indent both need /// adjusting (MD030 `ul-single`/`ul-multi` = 3) used to need several passes in the /// editor because the LSP formatting handler applied fixes in a single pass. /// `rumdl check --fix` converges in one run by iterating to a fixpoint; the /// formatting handler must do the same. #[tokio::test] async fn test_formatting_idempotent_cascading_list_indent_issue_145() { let server = server_with_md030_spacing(3, 3).await; let uri = Url::parse("file:///nested.md").unwrap(); // The exact testcase from the issue. let input = indoc! {" - Bullet 1 - Sub-bullet with long text that is long enough that it is wrapped onto multiple lines. - Bullet 2 "}; let (after_first, after_second) = format_twice(&server, &uri, input).await; assert_eq!( after_first, after_second, "formatting must reach a fixpoint in one pass (rvben/rumdl-vscode#145):\n--- after first pass ---\n{after_first}\n--- after second pass ---\n{after_second}" ); // A single pass must also land on the exact fixpoint that `rumdl check --fix` // (the iterative engine) produces for this input and config. With the markers // widened to `- ` (content column 4), the sub-bullet stays nested under the // parent at column 4 rather than detaching to column 2 (MD007 aligns it to the // parent's widened content column). let expected = indoc! {" - Bullet 1 - Sub-bullet with long text that is long enough that it is wrapped onto multiple lines. - Bullet 2 "}; assert_eq!( after_first, expected, "one formatting pass should match the `rumdl check --fix` fixpoint, got:\n{after_first}" ); } /// Same root cause as #145 but with continuation lines at both nesting levels: /// widening the markers cascades into re-indenting each level's continuation, so /// a single-pass formatter could not converge. One pass must now be a fixpoint. #[tokio::test] async fn test_formatting_idempotent_nested_continuation_both_levels() { let server = server_with_md030_spacing(3, 3).await; let uri = Url::parse("file:///both-levels.md").unwrap(); let input = "- Outer item with text long enough that it is\n wrapped onto a second line here.\n - Inner item with text long enough that it is\n wrapped onto a second line here.\n"; let (after_first, after_second) = format_twice(&server, &uri, input).await; assert_eq!( after_first, after_second, "formatting must reach a fixpoint in one pass with continuation at both levels:\n--- after first pass ---\n{after_first}\n--- after second pass ---\n{after_second}" ); // Both markers were widened to three spaces after the bullet. assert!( after_first.contains("- Outer"), "outer marker widened, got:\n{after_first}" ); assert!( after_first.contains("- Inner"), "inner marker widened, got:\n{after_first}" ); } /// The formatting handler routes through `apply_all_fixes`, which must keep /// applying the LSP-specific config (VS Code settings), not just the on-disk /// file config. Disabling MD030 via the LSP `disable_rules` setting must stop /// the formatter from re-spacing list markers, even though the file config /// enables MD030 `ul-single`/`ul-multi` = 3. #[tokio::test] async fn test_formatting_honors_lsp_disable_rules() { let server = server_with_md030_spacing(3, 3).await; // LSP-specific override: a VS Code user/workspace setting disabling MD030. server.config.write().await.disable_rules = Some(vec!["MD030".to_string()]); let uri = Url::parse("file:///lsp-disable.md").unwrap(); let input = "- Bullet 1\n - Sub-bullet here.\n- Bullet 2\n"; let (after_first, _after_second) = format_twice(&server, &uri, input).await; // MD030 is disabled through LSP settings, so markers keep their single space. assert!( !after_first.contains("- "), "LSP disable_rules must suppress MD030 marker spacing during formatting, got:\n{after_first}" ); assert!( after_first.contains("- Bullet 1"), "single-space marker must be preserved, got:\n{after_first}" ); } /// One workspace/working-directory arrangement to resolve a file under. struct WorkspaceDiscoveryCase { name: &'static str, /// The MD007 indent `project/.rumdl.toml` sets, or `None` to leave the project /// without a config of its own. project_indent: Option, /// The workspace root the client declares, relative to the temp root. workspace_root: &'static str, /// The directory holding the file being edited, relative to the temp root. file_dir: &'static str, /// The MD007 indent the file must resolve to. expected_indent: usize, } /// The server must resolve a file's configuration from the workspace, never from /// the directory the editor happened to launch it in. /// /// `rumdl check` discovers upward from the working directory because that is the /// scope the user chose. A server's working directory is whatever the editor was /// started in, so an unrelated project sitting there used to supply the settings /// for a workspace that had none. Each case pins the resolved value against what /// `rumdl check` resolves for the same file, and against the value itself so a /// change moving both together could not pass. /// /// Mutates the process working directory, so it runs serially. #[tokio::test] #[serial_test::serial] async fn test_lsp_resolves_from_the_workspace_not_the_working_directory() { use crate::config::{Config, SourcedConfig}; use std::fs; use tempfile::tempdir; const USER_INDENT: usize = 5; const CWD_INDENT: usize = 7; let cases = [ // The reported divergence: nothing in the workspace, so an unrelated // project at the working directory used to answer for it. WorkspaceDiscoveryCase { name: "cwd_config_does_not_leak_into_the_workspace", project_indent: None, workspace_root: "project", file_dir: "project/nested", expected_indent: USER_INDENT, }, WorkspaceDiscoveryCase { name: "workspace_config_outranks_the_working_directory", project_indent: Some(3), workspace_root: "project", file_dir: "project/nested", expected_indent: 3, }, // Opening a subdirectory as the workspace: the per-file walk stops at the // declared root, so only the workspace-level walk can reach the config // above it, which is the one `rumdl check` finds from the same file. WorkspaceDiscoveryCase { name: "config_above_the_workspace_root_still_applies", project_indent: Some(3), workspace_root: "project/docs", file_dir: "project/docs", expected_indent: 3, }, ]; let mut failures = Vec::new(); for case in cases { let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let project = root.join("project"); let other = root.join("other"); let user_config_dir = root.join("xdg"); let home_dir = root.join("fakehome"); fs::create_dir_all(project.join("nested")).unwrap(); fs::create_dir_all(project.join("docs")).unwrap(); fs::create_dir_all(project.join(".git")).unwrap(); fs::create_dir_all(other.join(".git")).unwrap(); fs::create_dir_all(user_config_dir.join("rumdl")).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( user_config_dir.join("rumdl").join("rumdl.toml"), format!("[MD007]\nindent = {USER_INDENT}\n"), ) .unwrap(); // An unrelated project that the server process happens to sit in. fs::write(other.join(".rumdl.toml"), format!("[MD007]\nindent = {CWD_INDENT}\n")).unwrap(); if let Some(indent) = case.project_indent { fs::write(project.join(".rumdl.toml"), format!("[MD007]\nindent = {indent}\n")).unwrap(); } let file_dir = root.join(case.file_dir); let md_file = file_dir.join("test.md"); fs::write(&md_file, "").unwrap(); let prev_cwd = std::env::current_dir().unwrap(); // What `rumdl check` resolves for this file, run from the file's directory. std::env::set_current_dir(&file_dir).unwrap(); let cli = SourcedConfig::load_with_discovery_impl(None, None, false, Some(&user_config_dir), Some(&home_dir)); std::env::set_current_dir(&prev_cwd).unwrap(); let cli_config: Config = cli.expect("CLI config should load").into_validated_unchecked().into(); let cli_indent = crate::config::get_rule_config_value::(&cli_config, "MD007", "indent"); // What the server resolves for it, launched from the unrelated project. let server = create_test_server(); server .workspace_roots .write() .await .push(root.join(case.workspace_root)); std::env::set_current_dir(&other).unwrap(); server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; std::env::set_current_dir(&prev_cwd).unwrap(); let lsp_config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; let lsp_indent = crate::config::get_rule_config_value::(&lsp_config, "MD007", "indent"); // Collected rather than asserted so one failing arrangement does not hide // the others. if cli_indent != Some(case.expected_indent) { failures.push(format!( "{}: the case does not describe what `rumdl check` resolves: expected MD007.indent {:?}, CLI resolved {cli_indent:?}", case.name, case.expected_indent )); } if lsp_indent != Some(case.expected_indent) { failures.push(format!( "{}: server resolved MD007.indent from the wrong scope: expected {:?}, got {lsp_indent:?}", case.name, case.expected_indent )); } } assert!(failures.is_empty(), "{}", failures.join("\n")); } /// Each workspace root is its own project. A file in a root that holds no config /// must not inherit the settings of a sibling root that does: `rumdl check` inside /// that root would resolve its own scope, and nothing about opening a second folder /// in the editor changes which project a file belongs to. #[tokio::test] async fn test_a_workspace_root_without_config_does_not_inherit_a_sibling_roots_config() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let configured = root.join("configured"); let bare = root.join("bare"); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&configured).unwrap(); fs::create_dir_all(&bare).unwrap(); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(configured.join(".rumdl.toml"), "[MD007]\nindent = 4\n").unwrap(); let configured_file = configured.join("doc.md"); let bare_file = bare.join("doc.md"); fs::write(&configured_file, "").unwrap(); fs::write(&bare_file, "").unwrap(); // Both folders are open, the configured one first, so it is the root the server // treats as primary. let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(configured.clone()); roots.push(bare.clone()); } server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; let in_configured = server .resolve_config_for_file_impl(&configured_file, Some(&user_config_dir), Some(&home_dir)) .await; let in_bare = server .resolve_config_for_file_impl(&bare_file, Some(&user_config_dir), Some(&home_dir)) .await; // Positive control: the config is reached where it belongs, so the assertion // below cannot pass for want of a working config. assert_eq!( crate::config::get_rule_config_value::(&in_configured, "MD007", "indent"), Some(4), "a file in the configured root must use that root's config" ); assert_eq!( crate::config::get_rule_config_value::(&in_bare, "MD007", "indent"), None, "a file in the root without a config must fall back to defaults, not the sibling root's config" ); } /// The per-file walk stops at the workspace root, so a config above the root is /// found only by resolving that root's own scope. Every root gets that treatment, /// not just the first one the editor happened to send. #[tokio::test] async fn test_a_secondary_workspace_root_resolves_a_config_above_itself() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let primary = root.join("primary"); let parent = root.join("parent"); let secondary = parent.join("secondary"); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&primary).unwrap(); fs::create_dir_all(&secondary).unwrap(); fs::create_dir_all(parent.join(".git")).unwrap(); // bound the upward walk here fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(primary.join(".rumdl.toml"), "[MD007]\nindent = 4\n").unwrap(); fs::write(parent.join(".rumdl.toml"), "[MD007]\nindent = 3\n").unwrap(); let md_file = secondary.join("doc.md"); fs::write(&md_file, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(primary.clone()); roots.push(secondary.clone()); } server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; let config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( crate::config::get_rule_config_value::(&config, "MD007", "indent"), Some(3), "the secondary root must resolve the config above it, not the primary root's" ); } /// A root whose own scope cannot be resolved is still not the primary root's project. /// Falling back to the server's startup config there would lint it under another /// project's settings for as long as the broken config stays broken. #[tokio::test] async fn test_a_secondary_workspace_root_with_a_broken_config_falls_back_to_defaults() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let primary = root.join("primary"); let parent = root.join("parent"); let secondary = parent.join("secondary"); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&primary).unwrap(); fs::create_dir_all(&secondary).unwrap(); fs::create_dir_all(parent.join(".git")).unwrap(); // bound the upward walk here fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(primary.join(".rumdl.toml"), "[MD007]\nindent = 4\n").unwrap(); fs::write(parent.join(".rumdl.toml"), "[MD007\nindent = 3\n").unwrap(); let md_file = secondary.join("doc.md"); fs::write(&md_file, "").unwrap(); let server = create_test_server(); { let mut roots = server.workspace_roots.write().await; roots.push(primary.clone()); roots.push(secondary.clone()); } server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; let config = server .resolve_config_for_file_impl(&md_file, Some(&user_config_dir), Some(&home_dir)) .await; assert_eq!( crate::config::get_rule_config_value::(&config, "MD007", "indent"), None, "an unresolvable scope must fall back to defaults, not to another root's config" ); } /// Block until the background index worker reports the workspace indexed. /// /// Panics rather than returning on timeout: every caller's assertion is /// meaningless against a half-built index, so a silent proceed would turn a /// stalled worker into a confident wrong answer. async fn wait_for_index_ready(server: &RumdlLanguageServer) { for _ in 0..1000 { if matches!(*server.index_state.read().await, crate::lsp::types::IndexState::Ready) { return; } tokio::time::sleep(std::time::Duration::from_millis(10)).await; } panic!("workspace index never became ready"); } /// Wait until one indexed file reaches a caller-defined state. async fn wait_for_index_entry( server: &RumdlLanguageServer, path: &std::path::Path, matches: impl Fn(&crate::workspace_index::FileIndex) -> bool, ) { for _ in 0..1000 { let matched = { let index = server.workspace_index.read().await; index.get_file(path).is_some_and(&matches) }; if matched { return; } tokio::time::sleep(std::time::Duration::from_millis(10)).await; } panic!( "workspace index entry for {} never reached the expected state", path.display() ); } /// A nested config governs both the initial workspace scan and later debounced /// buffer updates. The flavor assertion catches path resolution drift; the /// anchor assertion catches rule construction from the root config. #[tokio::test] async fn test_workspace_index_uses_nested_config_for_full_and_incremental_updates() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let nested = root.join("docs"); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&nested).unwrap(); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( root.join(".rumdl.toml"), "[global]\nflavor = \"standard\"\n\n[MD051]\nanchor-style = \"python-markdown\"\n", ) .unwrap(); fs::write( nested.join(".rumdl.toml"), "[global]\nflavor = \"mkdocs\"\n\n[MD051]\nanchor-style = \"github\"\n", ) .unwrap(); let doc_path = nested.join("guide.md"); let initial = "# Getting Started โ€” Advanced\n\n# -8<- [start:section]\n"; fs::write(&doc_path, initial).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; { let index = server.workspace_index.read().await; let file = index.get_file(&doc_path).expect("nested document should be indexed"); assert_eq!(file.headings.len(), 1, "MkDocs must hide its snippet marker"); assert_eq!( file.headings[0].auto_anchor, "getting-started--advanced", "the nested MD051 anchor style must override the root rule config" ); } let changed = "# Updated โ€” Heading\n\n# -8<- [start:other]\n"; assert!( server .queue_index_update(IndexUpdate::FileChanged { path: doc_path.clone(), content: changed.to_string(), }) .await ); wait_for_index_entry(&server, &doc_path, |file| { file.headings.len() == 1 && file.headings[0].text == "Updated โ€” Heading" && file.headings[0].auto_anchor == "updated--heading" }) .await; } /// Editing a nested config clears the resolver cache and makes the rescan use /// the new scope. Waiting on the entry, rather than merely `IndexState::Ready`, /// avoids racing the worker before it observes the queued rescan. #[tokio::test] async fn test_nested_config_change_rebuilds_index_with_new_effective_config() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let nested = root.join("docs"); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&nested).unwrap(); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(root.join(".rumdl.toml"), "[global]\nflavor = \"standard\"\n").unwrap(); let nested_config = nested.join(".rumdl.toml"); fs::write( &nested_config, "[global]\nflavor = \"standard\"\n\n[MD051]\nanchor-style = \"python-markdown\"\n", ) .unwrap(); let doc_path = nested.join("guide.md"); fs::write(&doc_path, "# Getting Started โ€” Advanced\n\n# -8<- [start:section]\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; { let index = server.workspace_index.read().await; let file = index.get_file(&doc_path).expect("nested document should be indexed"); assert_eq!( file.headings.len(), 2, "control: Standard parses the marker as a heading" ); assert_eq!(file.headings[0].auto_anchor, "getting-started-advanced"); } fs::write( &nested_config, "[global]\nflavor = \"mkdocs\"\n\n[MD051]\nanchor-style = \"github\"\n", ) .unwrap(); server .did_change_watched_files(DidChangeWatchedFilesParams { changes: vec![FileEvent { uri: Url::from_file_path(&nested_config).unwrap(), typ: FileChangeType::CHANGED, }], }) .await; wait_for_index_entry(&server, &doc_path, |file| { file.headings.len() == 1 && file.headings[0].auto_anchor == "getting-started--advanced" }) .await; } /// Issue #792: MD051's `check-frontmatter` found a broken fragment under /// `rumdl check` but not under `rumdl server`. /// /// The server built its own workspace index instead of asking the rules what a /// file contributes, so the frontmatter link never entered the index and the /// cross-file check had nothing to resolve. Everything a rule's configuration /// decides about indexing was invisible to the editor. #[tokio::test] async fn test_frontmatter_link_fragments_are_checked_by_the_server() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( root.join(".rumdl.toml"), "[global]\nenable = [\"MD051\"]\n\n[MD051]\ncheck-frontmatter = true\n", ) .unwrap(); let doc_path = root.join("test.md"); let text = "---\ntitle: Heading 1\nlink: 'test.md#heading'\n---\n\nThis is a Markdown file.\n"; fs::write(&doc_path, text).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let uri = Url::from_file_path(&doc_path).unwrap(); server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: uri.clone(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; let report = server .diagnostic(DocumentDiagnosticParams { text_document: TextDocumentIdentifier { uri }, identifier: None, previous_result_id: None, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }) .await .expect("diagnostic request should succeed"); let DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(report)) = report else { panic!("expected a full diagnostic report"); }; let diagnostics = report.full_document_diagnostic_report.items; let md051: Vec<_> = diagnostics .iter() .filter(|d| d.code == Some(NumberOrString::String("MD051".to_string()))) .collect(); assert_eq!( md051.len(), 1, "the frontmatter fragment should be flagged exactly once, got {diagnostics:?}" ); assert_eq!( md051[0].range.start.line, 2, "the diagnostic belongs on the frontmatter line holding the link" ); assert!( md051[0].message.contains("heading") && md051[0].message.contains("test.md"), "unexpected message: {}", md051[0].message ); } /// The control for the test above: the same document without the configuration /// that asks for frontmatter checking must stay clean, so a passing run proves /// the server honored `check-frontmatter` rather than flagging frontmatter /// unconditionally. #[tokio::test] async fn test_frontmatter_link_fragments_are_left_alone_by_default() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(root.join(".rumdl.toml"), "[global]\nenable = [\"MD051\"]\n").unwrap(); let doc_path = root.join("test.md"); let text = "---\ntitle: Heading 1\nlink: 'test.md#heading'\n---\n\nThis is a Markdown file.\n"; fs::write(&doc_path, text).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let uri = Url::from_file_path(&doc_path).unwrap(); server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: uri.clone(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; let report = server .diagnostic(DocumentDiagnosticParams { text_document: TextDocumentIdentifier { uri }, identifier: None, previous_result_id: None, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }) .await .expect("diagnostic request should succeed"); let DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(report)) = report else { panic!("expected a full diagnostic report"); }; assert!( report.full_document_diagnostic_report.items.is_empty(), "frontmatter is not checked without check-frontmatter, got {:?}", report.full_document_diagnostic_report.items ); } /// `initialize` canonicalizes each workspace root, so every index key descends /// from a canonical path. A document arrives as whatever URI the editor sent, /// which resolves to a path that need not be canonical: it can run through a /// symlinked ancestor, and on Windows it never carries the `\\?\` prefix that /// `canonicalize` adds. Looking the document up in its own index by that raw /// path found nothing, and every cross-file diagnostic silently disappeared. /// /// The symlink is the portable way to build the skew. Windows reaches the same /// state with no symlink at all, which is how the test above caught this. #[cfg(unix)] #[tokio::test] async fn test_cross_file_diagnostics_survive_a_symlinked_workspace_root() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let real = base.join("real"); let link = base.join("link"); fs::create_dir_all(&real).unwrap(); std::os::unix::fs::symlink(&real, &link).unwrap(); let user_config_dir = base.join("userconfig"); let home_dir = base.join("fakehome"); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( real.join(".rumdl.toml"), "[global]\nenable = [\"MD051\"]\n\n[MD051]\ncheck-frontmatter = true\n", ) .unwrap(); let text = "---\ntitle: Heading 1\nlink: 'test.md#heading'\n---\n\nThis is a Markdown file.\n"; fs::write(real.join("test.md"), text).unwrap(); let server = create_test_server(); // What `initialize` stores: the root as the editor sent it, canonicalized. *server.workspace_roots.write().await = vec![link.resolve_like_server()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; // What the editor sends: the path the user navigated to, through the symlink. let uri = Url::from_file_path(link.join("test.md")).unwrap(); server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: uri.clone(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; let report = server .diagnostic(DocumentDiagnosticParams { text_document: TextDocumentIdentifier { uri }, identifier: None, previous_result_id: None, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }) .await .expect("diagnostic request should succeed"); let DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(report)) = report else { panic!("expected a full diagnostic report"); }; let diagnostics = report.full_document_diagnostic_report.items; let md051: Vec<_> = diagnostics .iter() .filter(|d| d.code == Some(NumberOrString::String("MD051".to_string()))) .collect(); assert_eq!( md051.len(), 1, "a document opened through a symlinked root still resolves to its index entry, got {diagnostics:?}" ); } /// The other half of the resolution boundary: navigation resolves a link target /// and asks for that document's content by the resolved spelling, while the /// document store is keyed by the spelling the editor opened. Under a symlinked /// root the two differ, so without the alias the request falls through to the /// file on disk and previews content the buffer no longer has. #[cfg(unix)] #[tokio::test] async fn test_hover_previews_the_open_buffer_under_a_symlinked_root() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let real = base.join("real"); let link = base.join("link"); fs::create_dir_all(&real).unwrap(); std::os::unix::fs::symlink(&real, &link).unwrap(); let disk = "# Section\n\nDISK BODY\n\n[jump](#section)\n"; let buffer = "# Section\n\nBUFFER BODY\n\n[jump](#section)\n"; fs::write(real.join("doc.md"), disk).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![link.resolve_like_server()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let uri = Url::from_file_path(link.join("doc.md")).unwrap(); server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: uri.clone(), language_id: "markdown".to_string(), version: 1, text: buffer.to_string(), }, }) .await; let hover = server .hover(HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri }, position: Position { line: 4, character: 8 }, }, work_done_progress_params: WorkDoneProgressParams::default(), }) .await .expect("hover should succeed"); let rendered = format!("{hover:?}"); assert!( rendered.contains("BUFFER BODY"), "hover previewed the disk copy instead of the open buffer: {rendered}" ); } /// One file can be open under both spellings at once, and the editor holds a /// separate buffer for each. A request names one of them, so the alias recorded /// for the other must not answer it. #[cfg(unix)] #[tokio::test] async fn test_hover_previews_the_buffer_the_request_names() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let real = base.join("real"); let link = base.join("link"); fs::create_dir_all(&real).unwrap(); std::os::unix::fs::symlink(&real, &link).unwrap(); let body = |marker: &str| format!("# Section\n\n{marker} BODY\n\n[jump](#section)\n"); fs::write(real.join("doc.md"), body("DISK")).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![link.resolve_like_server()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; // The symlinked spelling is opened first, so its alias is the one on record. for (path, marker) in [(link.join("doc.md"), "LINK"), (real.join("doc.md"), "REAL")] { server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: Url::from_file_path(path).unwrap(), language_id: "markdown".to_string(), version: 1, text: body(marker), }, }) .await; } let hover = server .hover(HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::from_file_path(real.join("doc.md")).unwrap(), }, position: Position { line: 4, character: 8 }, }, work_done_progress_params: WorkDoneProgressParams::default(), }) .await .expect("hover should succeed"); let rendered = format!("{hover:?}"); assert!( rendered.contains("REAL BODY"), "hover answered for the other spelling's buffer: {rendered}" ); } /// A hover that previews a document nobody has opened caches it from disk under /// the resolved spelling. Opening that document makes the editor's buffer the /// truth, so the cached copy must stop answering for it. #[cfg(unix)] #[tokio::test] async fn test_hover_prefers_a_newly_opened_buffer_over_its_cached_disk_copy() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let real = base.join("real"); let link = base.join("link"); fs::create_dir_all(&real).unwrap(); std::os::unix::fs::symlink(&real, &link).unwrap(); let index = "# Index\n\n[doc](doc.md)\n"; fs::write(real.join("index.md"), index).unwrap(); fs::write(real.join("doc.md"), "# Doc\n\nDISK BODY\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![link.resolve_like_server()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let open = async |path: std::path::PathBuf, text: &str| { server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: Url::from_file_path(path).unwrap(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; }; let hover_over_the_link = async || { server .hover(HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::from_file_path(link.join("index.md")).unwrap(), }, // Inside the link destination, which is where hover reads one. position: Position { line: 2, character: 8 }, }, work_done_progress_params: WorkDoneProgressParams::default(), }) .await .expect("hover should succeed") }; open(link.join("index.md"), index).await; let first = format!("{:?}", hover_over_the_link().await); assert!( first.contains("DISK BODY"), "a document nobody opened is previewed from disk: {first}" ); open(link.join("doc.md"), "# Doc\n\nBUFFER BODY\n").await; let second = format!("{:?}", hover_over_the_link().await); assert!( second.contains("BUFFER BODY"), "hover kept previewing the disk copy cached before the document was opened: {second}" ); } /// Two symlinks to one directory let the editor open the same file under two /// spellings, so closing either must leave the other reachable. /// /// Both directions are asserted because each pins a different mistake. Closing /// the first-opened spelling catches an alias removed by resolved path alone, /// which strands the buffer still open; closing the last-opened one catches a /// single alias slot, where the second open already displaced the first. #[cfg(unix)] #[tokio::test] async fn test_closing_one_spelling_leaves_the_other_reachable() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; for (closed_first, expected) in [(true, "B BODY"), (false, "A BODY")] { let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let real = base.join("real"); fs::create_dir_all(&real).unwrap(); let link_a = base.join("link_a"); let link_b = base.join("link_b"); std::os::unix::fs::symlink(&real, &link_a).unwrap(); std::os::unix::fs::symlink(&real, &link_b).unwrap(); let index = "# Index\n\n[doc](doc.md)\n"; fs::write(real.join("index.md"), index).unwrap(); fs::write(real.join("doc.md"), "# Doc\n\nDISK BODY\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![link_a.resolve_like_server()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; for (path, text) in [ (link_a.join("index.md"), index), (link_a.join("doc.md"), "# Doc\n\nA BODY\n"), (link_b.join("doc.md"), "# Doc\n\nB BODY\n"), ] { server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: Url::from_file_path(path).unwrap(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; } let closing = if closed_first { link_a.join("doc.md") } else { link_b.join("doc.md") }; server .did_close(DidCloseTextDocumentParams { text_document: TextDocumentIdentifier { uri: Url::from_file_path(closing).unwrap(), }, }) .await; // Resolves to `real/doc.md`, which neither remaining buffer is keyed by. let hover = server .hover(HoverParams { text_document_position_params: TextDocumentPositionParams { text_document: TextDocumentIdentifier { uri: Url::from_file_path(link_a.join("index.md")).unwrap(), }, position: Position { line: 2, character: 8 }, }, work_done_progress_params: WorkDoneProgressParams::default(), }) .await .expect("hover should succeed"); let rendered = format!("{hover:?}"); assert!( rendered.contains(expected), "closing the {} spelling lost the buffer still open under the other, wanted {expected}: {rendered}", if closed_first { "first-opened" } else { "last-opened" } ); } } /// The index worker reuses one index configuration per directory even when a /// project opts into `.editorconfig`, whose globs can distinguish two files in /// that directory. That optimization rests on an assumption this pins: `.editorconfig` /// reaches MD007, MD009, MD010, MD013 and MD047, none of which is /// workspace-scoped, while the index is built from the workspace-scoped rules /// and the file's flavor alone. So two files a `.editorconfig` genuinely /// separates still index identically, and the gate costs a rule-set /// construction per file for no difference. Should a workspace-scoped rule ever /// read a setting `.editorconfig` supplies, this fails and the cache must become /// sensitive to the file. #[tokio::test] async fn test_index_is_independent_of_editorconfig_settings() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write( root.join(".rumdl.toml"), "[global]\neditorconfig = true\n\n[MD051]\nanchor-style = \"github\"\n", ) .unwrap(); fs::write( root.join(".editorconfig"), "root = true\n\n[a.md]\nmax_line_length = 40\nindent_size = 2\n\n[b.md]\nmax_line_length = 120\nindent_size = 8\n", ) .unwrap(); let a = root.join("a.md"); let b = root.join("b.md"); let content = "# Heading One\n\nSee [x](other.md#anchor) and [y](#heading-one).\n\n* item\n * nested\n"; fs::write(&a, content).unwrap(); fs::write(&b, content).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; let ca = server .resolve_config_for_file_impl(&a, Some(&user_config_dir), Some(&home_dir)) .await; let cb = server .resolve_config_for_file_impl(&b, Some(&user_config_dir), Some(&home_dir)) .await; // Control: the two files really are separated, or the comparison below is // vacuous. MD013's limit arrives as the global one, MD007's as its own. let indent = |c: &crate::config::Config| { c.rules .get("MD007") .and_then(|r| r.values.get("indent")) .map(ToString::to_string) }; assert_ne!(indent(&ca), indent(&cb), "control: editorconfig must reach the configs"); assert_ne!( ca.global.line_length, cb.global.line_length, "control: editorconfig must reach the configs" ); let index_of = |c: &crate::config::Config, p: &std::path::Path| { let rules = crate::lsp::index_worker::cross_file_rules(c); let index = crate::lsp::index_worker::IndexWorker::build_file_index(content, &rules, c.get_flavor_for_file(p), Some(p)); assert!( !index.headings.is_empty() && !index.cross_file_links.is_empty(), "control: the index must hold something for the comparison to mean anything" ); format!("{:?}{:?}", index.headings, index.cross_file_links) }; assert_eq!( index_of(&ca, &a), index_of(&cb, &b), "no editorconfig setting reaches a workspace-scoped rule, so the index cannot differ" ); } /// The manual "Reflow paragraph" action measures the paragraph on LF text: /// its byte offsets count one byte per line ending, and it joins the reflowed /// lines with `\n`. Offered on a CRLF buffer as-is, the range drifted one /// column per preceding line ending (here it began on the blank line above the /// paragraph and ended inside "second line") and the replacement was LF, so /// applying it swallowed text and mixed the endings. #[tokio::test] async fn test_reflow_action_on_crlf_document_matches_the_lf_action() { let server = create_test_server(); let uri = Url::parse("file:///reflow-crlf.md").unwrap(); let long = "word ".repeat(30); let lf = format!("# Title\n\nintro\n{long}text\nsecond line\n\ntail\n"); let crlf = lf.replace('\n', "\r\n"); let range = Range { start: Position { line: 3, character: 0 }, end: Position { line: 3, character: 0 }, }; async fn reflow_edit(server: &RumdlLanguageServer, uri: &Url, text: &str, range: Range) -> TextEdit { let actions = server.get_code_actions(uri, text, range).await.unwrap(); let action = actions .into_iter() .find(|a| a.title == "Reflow paragraph") .expect("MD013 must offer the reflow action on line 4"); let mut edits = action.edit.unwrap().changes.unwrap().remove(uri).unwrap(); assert_eq!(edits.len(), 1); edits.pop().unwrap() } let lf_edit = reflow_edit(&server, &uri, &lf, range).await; let crlf_edit = reflow_edit(&server, &uri, &crlf, range).await; // Control: the LF action covers exactly the three-line paragraph. assert_eq!(lf_edit.range.start, Position { line: 2, character: 0 }); assert_eq!(lf_edit.range.end, Position { line: 5, character: 0 }); assert!(lf_edit.new_text.starts_with("intro word") && lf_edit.new_text.ends_with("second line\n")); assert_eq!( crlf_edit.range, lf_edit.range, "the CRLF action must cover the same lines" ); assert_eq!( crlf_edit.new_text, lf_edit.new_text.replace('\n', "\r\n"), "the CRLF action must reflow in the document's own line ending" ); } /// An inline `rumdl-configure-file` comment sets the MD013 options the manual /// "Reflow paragraph" action uses, exactly like the same keys in a config file. #[tokio::test] async fn test_reflow_action_honours_inline_configure_file() { let server = create_test_server(); let uri = Url::parse("file:///reflow-inline.md").unwrap(); let paragraph = "This is a long paragraph with enough words to exceed forty columns easily."; let text = format!( "# T\n\n\n\n{paragraph}\n" ); let range = Range { start: Position { line: 4, character: 0 }, end: Position { line: 4, character: 0 }, }; let actions = server.get_code_actions(&uri, &text, range).await.unwrap(); let action = actions .into_iter() .find(|a| a.title == "Reflow paragraph") .expect("MD013 must offer the reflow action on the over-long line"); let edits = action.edit.unwrap().changes.unwrap().remove(&uri).unwrap(); assert_eq!(edits.len(), 1); assert_eq!( edits[0].new_text, "This is a long paragraph with enough\nwords to exceed forty columns easily.\n" ); } #[tokio::test] async fn test_merge_conflict_blocks_formatting_options_and_code_actions() { let server = create_test_server(); let uri = Url::parse("file:///conflict.md").unwrap(); let text = "# Title\r\n\n<<<<<<< HEAD\r\ntext "; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }, ); let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); assert_eq!(diagnostics.len(), 1); assert_eq!(diagnostics[0].code, Some(NumberOrString::String("MD092".into()))); assert_eq!(diagnostics[0].range.start.line, 2); let result = server .formatting(DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: editor_formatting_options(), work_done_progress_params: WorkDoneProgressParams::default(), }) .await .unwrap(); assert!(result.unwrap().is_empty()); assert!(server.apply_all_fixes(&uri, text).await.unwrap().is_none()); assert!( server .get_code_actions(&uri, text, Range::new(Position::new(0, 0), Position::new(4, 0))) .await .unwrap() .is_empty() ); } // ========================================================================= // Multi-line setext heading navigation // ========================================================================= /// Build a file index the way the index worker does, so a test sees the /// heading span the workspace index really carries. fn index_for(content: &str, path: &std::path::Path) -> crate::workspace_index::FileIndex { let config = crate::config::Config::default(); let rules = crate::lsp::index_worker::cross_file_rules(&config); crate::lsp::index_worker::IndexWorker::build_file_index( content, &rules, crate::config::MarkdownFlavor::Standard, Some(path), ) } /// A setext underline makes a heading of the whole paragraph above it, so this /// document's heading is `Installation Guide for rumdl`, written on two lines /// and anchored on their joined text. const SETEXT_SPAN_DOC: &str = "Installation Guide\nfor rumdl\n------------------\n\nSee [guide](#installation-guide-for-rumdl).\n\n## Usage\n\nUse it.\n"; /// Seed a server with `SETEXT_SPAN_DOC` as an open document and its real index. async fn setext_span_server(dir: &str) -> (RumdlLanguageServer, std::path::PathBuf, Url) { let server = create_test_server(); let file = test_temp_path(dir).join("doc.md"); let uri = Url::from_file_path(&file).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: SETEXT_SPAN_DOC.to_string(), version: Some(1), from_disk: false, }, ); let file_index = index_for(SETEXT_SPAN_DOC, &file); server .workspace_index .write() .await .insert_file(file.clone(), file_index); (server, file, uri) } /// Every line of the paragraph is heading text, so a cursor on the first one is /// on the heading, and the renameable range runs to the end of the last line. #[tokio::test] async fn test_prepare_rename_on_the_first_line_of_a_multi_line_setext_heading() { let (server, _file, uri) = setext_span_server("rumdl-setext-prepare-rename").await; let result = server .handle_prepare_rename(&uri, Position { line: 0, character: 3 }) .await; let Some(PrepareRenameResponse::Range(range)) = result else { panic!("the first line of a setext heading must be renameable, got {result:?}"); }; assert_eq!(range.start, Position { line: 0, character: 0 }); assert_eq!(range.end, Position { line: 1, character: 9 }, "end of `for rumdl`"); } /// Renaming replaces the whole heading text with the new name on one line, so /// the earlier text lines do not survive beside it and the anchor changes as /// the edit to every link predicts. #[tokio::test] async fn test_rename_multi_line_setext_heading_replaces_the_whole_span() { let (server, _file, uri) = setext_span_server("rumdl-setext-rename").await; let result = server .handle_rename(&uri, Position { line: 0, character: 3 }, "Setup") .await; let edit = result.expect("renaming from the heading's first line must produce an edit"); let changes = edit.changes.expect("the edit carries changes"); let edits = changes.get(&uri).expect("the document is edited"); let heading_edits: Vec<_> = edits.iter().filter(|e| e.new_text == "Setup").collect(); assert_eq!(heading_edits.len(), 1, "one edit for the heading text: {edits:?}"); assert_eq!(heading_edits[0].range.start, Position { line: 0, character: 0 }); assert_eq!( heading_edits[0].range.end, Position { line: 1, character: 9 }, "the edit covers both text lines" ); assert!( edits.iter().any(|e| e.new_text == "setup"), "the link to the old anchor is updated: {edits:?}" ); } /// A heading written on a list marker line is renamed in place: the edit starts /// after the marker, so the list item survives, and the link to the old anchor /// follows the new name. #[tokio::test] async fn test_rename_heading_on_a_list_marker_line_keeps_the_list_item() { for (content, expected_start, expected_end) in [ ("- Alpha\n ---\n\nSee [x](#alpha).\n", 2, 7), ("- ## Alpha\n\nSee [x](#alpha).\n", 5, 10), ] { let server = create_test_server(); let file = test_temp_path("rumdl-marker-rename").join("doc.md"); let uri = Url::from_file_path(&file).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); server .workspace_index .write() .await .insert_file(file.clone(), index_for(content, &file)); let edit = server .handle_rename(&uri, Position { line: 0, character: 4 }, "Beta") .await .unwrap_or_else(|| panic!("{content:?}: renaming must produce an edit")); let changes = edit.changes.expect("the edit carries changes"); let edits = changes.get(&uri).expect("the document is edited"); let heading_edits: Vec<_> = edits.iter().filter(|e| e.new_text == "Beta").collect(); assert_eq!( heading_edits.len(), 1, "{content:?}: one edit for the heading: {edits:?}" ); assert_eq!( heading_edits[0].range, Range { start: Position { line: 0, character: expected_start }, end: Position { line: 0, character: expected_end }, }, "{content:?}: the edit covers only the heading text" ); assert!( edits.iter().any(|e| e.new_text == "beta"), "{content:?}: the link follows the rename: {edits:?}" ); } } /// An index that lags the buffer must not steer an edit into text that is no /// longer the heading it describes. #[tokio::test] async fn test_rename_declines_when_the_index_describes_a_different_heading() { let server = create_test_server(); let file = test_temp_path("rumdl-stale-rename").join("doc.md"); let uri = Url::from_file_path(&file).unwrap(); let indexed = "- a\n b\n ---\n"; let buffer = "- a\n- # b\n"; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: buffer.to_string(), version: Some(2), from_disk: false, }, ); server .workspace_index .write() .await .insert_file(file.clone(), index_for(indexed, &file)); let position = Position { line: 1, character: 5 }; assert!(server.handle_prepare_rename(&uri, position).await.is_none()); assert!(server.handle_rename(&uri, position, "new").await.is_none()); } /// Following a link to the heading's anchor lands on the line the heading /// starts on, not on the last line of its text. #[tokio::test] async fn test_goto_anchor_lands_on_the_first_line_of_a_multi_line_setext_heading() { let server = create_test_server(); let dir = test_temp_path("rumdl-setext-goto"); let current_file = dir.join("index.md"); let target_file = dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let content = "# Index\n\nSee [guide](guide.md#installation-guide-for-rumdl).\n"; server.documents.write().await.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); let file_index = index_for(SETEXT_SPAN_DOC, &target_file); server .workspace_index .write() .await .insert_file(target_file.clone(), file_index); let result = server .handle_goto_definition(¤t_uri, Position { line: 2, character: 20 }) .await; let Some(GotoDefinitionResponse::Scalar(location)) = result else { panic!("the anchor must resolve, got {result:?}"); }; assert_eq!(location.uri, Url::from_file_path(&target_file).unwrap()); assert_eq!( location.range.start.line, 0, "the heading starts on its first text line" ); } /// The hover preview of an anchor shows the heading it targets, so it begins /// with the heading's own first line and ends where the section does. #[tokio::test] async fn test_hover_preview_of_a_multi_line_setext_heading_starts_at_its_text() { let server = create_test_server(); let dir = test_temp_path("rumdl-setext-hover"); let current_file = dir.join("index.md"); let target_file = dir.join("guide.md"); let current_uri = Url::from_file_path(¤t_file).unwrap(); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = "# Index\n\nSee [guide](guide.md#installation-guide-for-rumdl).\n"; { let mut documents = server.documents.write().await; documents.insert( current_uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); documents.insert( target_uri.clone(), DocumentEntry { content: SETEXT_SPAN_DOC.to_string(), version: Some(1), from_disk: false, }, ); } let file_index = index_for(SETEXT_SPAN_DOC, &target_file); server .workspace_index .write() .await .insert_file(target_file.clone(), file_index); let hover = server .handle_hover(¤t_uri, Position { line: 2, character: 20 }) .await .expect("the anchor resolves to a preview"); let HoverContents::Markup(markup) = hover.contents else { panic!("expected markup hover contents"); }; assert!( markup .value .starts_with("**guide.md**\n\nInstallation Guide\nfor rumdl\n---"), "the preview names the file, then begins with the heading: got {}", markup.value ); assert!( !markup.value.contains("## Usage"), "the preview stops at the next heading of the same level: got {}", markup.value ); } #[tokio::test] async fn explicit_embedded_markdown_variants_respect_lint_slot_in_lsp() { let uri = Url::parse("file:///test.md").unwrap(); let text = "# Test\n\n```markdown\n# Hello\n```\n"; for lint_enabled in [false, true] { let server = create_test_server(); { let mut cfg = server.rumdl_config.write().await; cfg.code_block_tools = make_embedded_markdown_config(); let markdown = cfg.code_block_tools.languages.get_mut("markdown").unwrap(); markdown.lint = if lint_enabled { vec!["rumdl:lint".to_string()] } else { Vec::new() }; markdown.format = vec!["rumdl:format".to_string()]; } let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); assert_eq!( diagnostics.iter().any(|d| d.range.start.line == 3), lint_enabled, "{diagnostics:?}" ); } } #[tokio::test] async fn test_merge_conflict_suppression_allows_editor_formatting() { for directive in [ "", "", "", ] { let server = create_test_server(); let uri = Url::from_file_path(test_temp_path("conflict-example.md")).unwrap(); let text = format!("# Title\n\n{directive}\n```text\n<<<<<<< HEAD\n```\n\n\nText \n"); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.clone(), version: Some(1), from_disk: false, }, ); let diagnostics = server.lint_document(&uri, &text, true).await.unwrap(); assert!( !diagnostics .iter() .any(|d| d.code == Some(NumberOrString::String("MD092".into()))) ); assert!( diagnostics .iter() .any(|d| d.code == Some(NumberOrString::String("MD009".into()))) ); let edits = server .formatting(DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: editor_formatting_options(), work_done_progress_params: WorkDoneProgressParams::default(), }) .await .unwrap() .unwrap(); assert_eq!(edits.len(), 1); assert_eq!(edits[0].new_text, text.replace("Text ", "Text")); assert!(server.apply_all_fixes(&uri, &text).await.unwrap().is_some()); // Re-enabling restores the whole-document guard, including editor options. if !directive.contains("configure-file") { let conflicted = format!("{text}\n>>>>>>> branch"); server.documents.write().await.get_mut(&uri).unwrap().content = conflicted.clone(); assert!(server.apply_all_fixes(&uri, &conflicted).await.unwrap().is_none()); let edits = server .formatting(DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: editor_formatting_options(), work_done_progress_params: WorkDoneProgressParams::default(), }) .await .unwrap() .unwrap(); assert!(edits.is_empty()); } } } /// A document open in the editor is indexed before it is ever saved. A link to /// it has no file on disk to resolve to, which MD057 reports, but its fragment /// can still only mean one of the open document's headings. #[tokio::test] async fn test_a_fragment_into_an_unsaved_open_document_is_checked() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let user_config_dir = root.join("userconfig"); let home_dir = root.join("fakehome"); fs::create_dir_all(&user_config_dir).unwrap(); fs::create_dir_all(&home_dir).unwrap(); fs::write(root.join(".rumdl.toml"), "[global]\nenable = [\"MD051\", \"MD057\"]\n").unwrap(); let doc_path = root.join("readme.md"); let text = "# Readme\n\n[broken](unsaved.md#missing) and [valid](unsaved.md#setup)\n"; fs::write(&doc_path, text).unwrap(); let unsaved_path = root.join("unsaved.md"); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server .load_configuration_impl(false, Some(&user_config_dir), Some(&home_dir)) .await; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; for (path, content) in [(&unsaved_path, "# Setup\n"), (&doc_path, text)] { server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: Url::from_file_path(path).unwrap(), language_id: "markdown".to_string(), version: 1, text: content.to_string(), }, }) .await; } wait_for_index_entry(&server, &unsaved_path, |index| !index.headings.is_empty()).await; wait_for_index_entry(&server, &doc_path, |index| !index.cross_file_links.is_empty()).await; assert!(!unsaved_path.exists(), "the open document must not be on disk"); let report = server .diagnostic(DocumentDiagnosticParams { text_document: TextDocumentIdentifier { uri: Url::from_file_path(&doc_path).unwrap(), }, identifier: None, previous_result_id: None, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }) .await .expect("diagnostic request should succeed"); let DocumentDiagnosticReportResult::Report(DocumentDiagnosticReport::Full(report)) = report else { panic!("expected a full diagnostic report"); }; let md051: Vec<&str> = report .full_document_diagnostic_report .items .iter() .filter(|d| d.code == Some(NumberOrString::String("MD051".to_string()))) .map(|d| d.message.as_str()) .collect(); assert_eq!( md051, ["Link fragment 'missing' not found in 'unsaved.md'"], "only #missing is absent from the open document" ); } /// Closing a document without saving discards its buffer, so the index must /// return to what the workspace scan would record for that path: the file on /// disk, or no entry when the scan would not index it. #[tokio::test] async fn test_did_close_returns_the_index_to_the_file_on_disk() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let root = base.join("ws"); fs::create_dir_all(&root).unwrap(); let saved = root.join("saved.md"); fs::write(&saved, "# Disk Heading\n").unwrap(); let never_saved = root.join("never-saved.md"); let outside = base.join("outside.md"); fs::write(&outside, "# Outside\n").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let heading_is = |text: &'static str| { move |file: &crate::workspace_index::FileIndex| file.headings.first().is_some_and(|h| h.text == text) }; for path in [&saved, &never_saved, &outside] { server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: Url::from_file_path(path).unwrap(), language_id: "markdown".to_string(), version: 1, text: "# Buffer Heading\n".to_string(), }, }) .await; wait_for_index_entry(&server, path, heading_is("Buffer Heading")).await; server .did_close(DidCloseTextDocumentParams { text_document: TextDocumentIdentifier { uri: Url::from_file_path(path).unwrap(), }, }) .await; } wait_for_index_entry(&server, &saved, heading_is("Disk Heading")).await; for gone in [&never_saved, &outside] { let mut removed = false; for _ in 0..1000 { if server.workspace_index.read().await.get_file(gone).is_none() { removed = true; break; } tokio::time::sleep(std::time::Duration::from_millis(10)).await; } assert!( removed, "{} is not in the workspace scan, so closing it must drop its entry", gone.display() ); } } /// A link destination is a URL: `my%20notes.md` names the file `my notes.md`, /// and a query string is not part of the file name. Navigation and anchor /// completion must resolve a destination to the same file MD057 checks. #[tokio::test] async fn test_navigation_resolves_percent_encoded_destinations() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); fs::create_dir_all(root.join("sub dir")).unwrap(); let target = root.join("sub dir").join("my notes.md"); fs::write(&target, "# Notes\n\n## Sub Part\n\nBody\n").unwrap(); let current = root.join("index.md"); let content = "# Index\n\n\ [a](sub%20dir/my%20notes.md#sub-part)\n\ [b]()\n\ [c](sub%20dir/my%20notes.md?plain=1#sub-part)\n\ [d](/sub%20dir/my%20notes.md#sub-part)\n\ [e](sub%20dir/my%20notes.md#)\n"; fs::write(¤t, content).unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let uri = Url::from_file_path(¤t).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: content.to_string(), version: Some(1), from_disk: false, }, ); for line in 2..=5 { let position = Position { line, character: 8 }; let Some(GotoDefinitionResponse::Scalar(location)) = server.handle_goto_definition(&uri, position).await else { panic!("line {line}: no definition"); }; assert_eq!(location.uri, Url::from_file_path(&target).unwrap(), "line {line}"); assert_eq!(location.range.start.line, 2, "line {line} must reach the heading"); let hover = server.handle_hover(&uri, position).await; assert!( format!("{hover:?}").contains("Sub Part"), "line {line}: hover must preview the heading: {hover:?}" ); } let anchors = server .get_anchor_completions( &uri, "sub%20dir/my%20notes.md", "", 30, Position { line: 6, character: 30 }, ) .await; assert!( anchors .iter() .any(|item| item.insert_text.as_deref() == Some("sub-part")), "anchor completion must list the target's headings: {anchors:?}" ); } /// Decoding must not turn an encoded `..` into a way out of the content roots. #[tokio::test] async fn test_root_relative_link_cannot_escape_the_content_root_by_encoding() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let base = temp.path().resolve_like_server(); let root = base.join("site"); fs::create_dir_all(&root).unwrap(); fs::write(base.join("secret.md"), "# Secret\n").unwrap(); let current = root.join("index.md"); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; for spelling in ["/../secret.md", "/%2E%2E/secret.md", "/%2e%2e%2fsecret.md"] { assert_eq!( server.resolve_link_path(¤t, spelling).await, None, "{spelling} must not resolve outside the content root" ); } } /// An accepted file completion must leave a link: `[d](my notes.md)` is plain /// text in CommonMark, so a path is inserted percent-encoded, and it must /// resolve back to the file it was offered for. What the user has typed /// matches in either spelling. #[tokio::test] async fn test_file_completion_inserts_a_destination_that_links_to_the_file() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let names = ["my notes.md", "50%.md", "a(b).md", "c#.md", "sub dir/deep.md"]; fs::create_dir_all(root.join("sub dir")).unwrap(); for name in names { fs::write(root.join(name), "# T\n").unwrap(); } let current = root.join("index.md"); fs::write(¤t, "").unwrap(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; server.config.write().await.link_completion_content_roots = vec![root.to_string_lossy().into_owned()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let uri = Url::from_file_path(¤t).unwrap(); let inserted = |item: &CompletionItem| match &item.text_edit { Some(CompletionTextEdit::Edit(edit)) => edit.new_text.clone(), other => panic!("expected a text edit: {other:?}"), }; let position = Position { line: 0, character: 4 }; let relative = server.get_file_completions(&uri, "", 4, position).await.items; let mut absolute = Vec::new(); for dir in ["/", "/sub%20dir/"] { absolute.extend(server.get_file_completions(&uri, dir, 4, position).await.items); } for (name, prefix) in names.iter().map(|n| (*n, "")).chain(names.iter().map(|n| (*n, "/"))) { let items = if prefix.is_empty() { &relative } else { &absolute }; let destination = items .iter() .map(inserted) .find(|text| crate::workspace_index::link_path_part(text) == format!("{prefix}{name}")) .unwrap_or_else(|| { panic!( "no completion names {prefix}{name}: {:?}", items.iter().map(inserted).collect::>() ) }); let link = format!("[d]({destination})\n"); let ctx = crate::lint_context::LintContext::new(&link, crate::config::MarkdownFlavor::Standard, None); assert_eq!( ctx.links().iter().map(|l| l.url.as_ref()).collect::>(), vec![destination.as_str()], "{link:?} must parse as one link to the inserted destination" ); assert_eq!( server.resolve_link_path(¤t, &destination).await, Some(root.join(name)), "{destination} must navigate to {name}" ); } // A typed prefix narrows in the spelling it was typed in. for typed in ["my n", "my%20n", "sub%20dir/d", "sub dir/d"] { let items = server.get_file_completions(&uri, typed, 4, position).await.items; assert_eq!( items.len(), 1, "{typed:?}: {:?}", items.iter().map(inserted).collect::>() ); } let items = server .get_file_completions(&uri, "/sub%20dir/de", 4, position) .await .items; assert_eq!( items.iter().map(inserted).collect::>(), vec!["/sub%20dir/deep.md"] ); } /// `only` names kinds hierarchically: a kind matches itself and the kinds /// beneath it after a `.`, never a longer or shorter spelling of a segment. #[tokio::test] async fn test_code_action_only_matches_whole_kind_segments() { let server = create_test_server(); let uri = Url::from_file_path(test_temp_path("rumdl-code-action-only/doc.md")).unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: "# Heading\n".to_string(), version: Some(1), from_disk: false, }, ); let kinds_for = |only: &[&str]| { let server = server.clone(); let uri = uri.clone(); let only = only.iter().map(|kind| CodeActionKind::from(kind.to_string())).collect(); async move { let params = CodeActionParams { text_document: TextDocumentIdentifier { uri }, range: Range { start: Position { line: 0, character: 0 }, end: Position { line: 0, character: 10 }, }, context: CodeActionContext { diagnostics: vec![], only: Some(only), trigger_kind: None, }, work_done_progress_params: WorkDoneProgressParams::default(), partial_result_params: PartialResultParams::default(), }; let mut kinds: Vec = server .code_action(params) .await .unwrap() .unwrap_or_default() .into_iter() .filter_map(|action| match action { CodeActionOrCommand::CodeAction(action) => action.kind.map(|kind| kind.as_str().to_string()), CodeActionOrCommand::Command(_) => None, }) .collect(); kinds.sort(); kinds.dedup(); kinds } }; // Positive controls: the exact kinds, their parents and the empty root kind. assert_eq!(kinds_for(&[""]).await, ["quickfix", "source.fixAll.rumdl"]); assert_eq!(kinds_for(&["quickfix"]).await, ["quickfix"]); assert_eq!(kinds_for(&["source"]).await, ["source.fixAll.rumdl"]); assert_eq!(kinds_for(&["source.fixAll"]).await, ["source.fixAll.rumdl"]); assert_eq!(kinds_for(&["source.fixAll.rumdl"]).await, ["source.fixAll.rumdl"]); // A kind is not a string prefix. for only in [ "quick", "source.fix", "source.fixAll.rumd", "quickfixes", "source.fixAll.rumdl.more", ] { assert!(kinds_for(&[only]).await.is_empty(), "{only}"); } } /// Format a range of `text` and return the edits, the way an editor's /// "Format Selection" asks for them. async fn range_format(text: &str, start: (u32, u32), end: (u32, u32)) -> Vec { let server = create_test_server(); let uri = Url::parse("file:///range.md").unwrap(); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }, ); let params = DocumentRangeFormattingParams { text_document: TextDocumentIdentifier { uri }, range: Range { start: Position { line: start.0, character: start.1, }, end: Position { line: end.0, character: end.1, }, }, options: editor_formatting_options(), work_done_progress_params: WorkDoneProgressParams::default(), }; server.range_formatting(params).await.unwrap().unwrap() } fn line_edit(start: (u32, u32), end: (u32, u32), new_text: &str) -> TextEdit { TextEdit { range: Range { start: Position { line: start.0, character: start.1, }, end: Position { line: end.0, character: end.1, }, }, new_text: new_text.to_string(), } } /// Range formatting changes only the lines the range touches. It used to /// return the whole formatted document, so "Format Selection" (and format on /// save of modified lines) rewrote text far outside the selection. #[tokio::test] async fn test_range_formatting_edits_only_the_requested_lines() { let text = "# T\n\ntrailing \n\n* item\n\nfoo\n"; // A range inside line 2 fixes line 2 and nothing else. assert_eq!( range_format(text, (2, 0), (2, 11)).await, vec![line_edit((2, 0), (3, 0), "trailing\n")] ); // A selection that ends at the start of the next line does not include it. assert_eq!( range_format(text, (2, 0), (4, 0)).await, vec![line_edit((2, 0), (3, 0), "trailing\n")] ); assert_eq!( range_format(text, (4, 3), (4, 3)).await, vec![line_edit((4, 0), (5, 0), "* item\n")] ); // Nothing to change in the range: no edits, even though the document has fixes. assert_eq!(range_format(text, (0, 0), (1, 0)).await, Vec::new()); // A range spanning both changes gets both. assert_eq!( range_format(text, (0, 0), (6, 3)).await, vec![ line_edit((2, 0), (3, 0), "trailing\n"), line_edit((4, 0), (5, 0), "* item\n"), ] ); } /// A change at the end of a document with no final newline replaces up to the /// end of the text, and a range away from it leaves it alone. #[tokio::test] async fn test_range_formatting_final_newline() { let text = "# T\n\ntext"; assert_eq!( range_format(text, (2, 0), (2, 4)).await, vec![line_edit((2, 0), (2, 4), "text\n")] ); assert_eq!(range_format(text, (0, 0), (0, 3)).await, Vec::new()); } /// An inserted line sits between two lines and belongs to both: the blank /// line MD022 adds below a heading comes with a range on either of them. #[tokio::test] async fn test_range_formatting_insertion_touches_both_neighbors() { let text = "# T\ntext\n\nmore\n"; let insert = vec![line_edit((1, 0), (1, 0), "\n")]; assert_eq!(range_format(text, (0, 0), (0, 3)).await, insert); assert_eq!(range_format(text, (1, 0), (1, 4)).await, insert); assert_eq!(range_format(text, (3, 0), (3, 4)).await, Vec::new()); } /// Hover over a link to `target_name#fragment` (or the bare file) in a document /// beside it, with the target indexed the way the workspace index builds it, /// and return the preview text. async fn hover_preview(dir: &str, target_name: &str, target_content: &str, link_target: &str) -> String { let server = create_test_server(); let docs_dir = test_temp_path(dir); let current_uri = Url::from_file_path(docs_dir.join("index.md")).unwrap(); let target_file = docs_dir.join(target_name); let target_uri = Url::from_file_path(&target_file).unwrap(); let content = format!("See [x]({link_target}).\n"); for (uri, text) in [(¤t_uri, content.as_str()), (&target_uri, target_content)] { server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }, ); } let rules = crate::rules::all_rules(&crate::config::Config::default()); let index = crate::build_file_index_only( target_content, &rules, crate::config::MarkdownFlavor::Standard, Some(target_file.clone()), ); server.workspace_index.write().await.insert_file(target_file, index); let hover = server .handle_hover(¤t_uri, Position { line: 0, character: 9 }) .await .expect("hover over the link"); let HoverContents::Markup(markup) = hover.contents else { panic!("Expected Markup hover contents"); }; markup.value } /// A file preview starts at the document's content: front matter would render /// as a thematic break and a Setext heading. #[tokio::test] async fn test_hover_file_preview_skips_front_matter() { let target = "---\ntitle: Guide\ntags: [a]\n---\n\n# Guide\n\nIntro.\n"; let preview = hover_preview("rumdl-hover-fm/docs", "guide.md", target, "guide.md").await; assert_eq!(preview, "**guide.md**\n\n# Guide\n\nIntro."); } /// The lines `line 1` through `line {n}`, each ending in a newline. fn numbered_lines(n: usize) -> String { use std::fmt::Write; (1..=n).fold(String::new(), |mut acc, i| { let _ = writeln!(acc, "line {i}"); acc }) } /// A preview cut off inside a fenced code block closes the fence, keeping the /// opener's container prefix, so the truncation marker and anything the editor /// shows after it do not render as code. #[tokio::test] async fn test_hover_file_preview_closes_a_truncated_fence() { let code = numbered_lines(20); let target = format!("# Guide\n\n````rust\n{code}````\n"); let preview = hover_preview("rumdl-hover-fence/docs", "guide.md", &target, "guide.md").await; let shown = numbered_lines(12); assert_eq!( preview, format!("**guide.md**\n\n# Guide\n\n````rust\n{shown}````\n\n...") ); let target = format!("# Guide\n\n- item\n\n ~~~\n{} ~~~\n", " code\n".repeat(20)); let preview = hover_preview("rumdl-hover-fence-list/docs", "guide.md", &target, "guide.md").await; assert!( preview.ends_with(" code\n ~~~\n\n..."), "the fence closes inside the list item: {preview:?}" ); // A fence opened on the list marker's line closes at the item's content column. let target = format!("# Guide\n\n> 1. ```\n{}> ```\n", "> code\n".repeat(20)); let preview = hover_preview("rumdl-hover-fence-marker/docs", "guide.md", &target, "guide.md").await; assert!( preview.ends_with("> code\n> ```\n\n..."), "the fence closes inside the blockquoted list item: {preview:?}" ); // A cut right after the closing fence adds no second one. let target = format!("# Guide\n\n```\n{}```\n\nMore.\n", "code\n".repeat(11)); let preview = hover_preview("rumdl-hover-fence-closed/docs", "guide.md", &target, "guide.md").await; assert!(preview.ends_with("code\n```\n\n..."), "{preview:?}"); } /// The anchor preview names its file like the file and line previews do, /// closes a fence it cuts off, and ends its section at a Setext heading too. #[tokio::test] async fn test_hover_anchor_preview_header_fence_and_setext_end() { let code = "x\n".repeat(20); let target = format!("# Guide\n\n## Setup\n\n```\n{code}```\n"); let preview = hover_preview("rumdl-hover-anchor/docs", "guide.md", &target, "guide.md#setup").await; let shown = "x\n".repeat(13); assert_eq!(preview, format!("**guide.md**\n\n## Setup\n\n```\n{shown}```\n\n...")); let target = "# Guide\n\n## Setup\n\nText.\n\nNext\n----\n\nOther.\n"; let preview = hover_preview("rumdl-hover-setext/docs", "guide.md", target, "guide.md#setup").await; assert_eq!(preview, "**guide.md**\n\n## Setup\n\nText.\n"); } /// Open `text` at a throwaway URI, send one didChange carrying `changes`, and /// return what the server then holds for the document. async fn content_after_changes(text: &str, changes: Vec) -> String { let server = create_test_server(); let uri = Url::from_file_path(test_temp_path("rumdl-did-change/doc.md")).unwrap(); server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: uri.clone(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; server .did_change(DidChangeTextDocumentParams { text_document: VersionedTextDocumentIdentifier { uri: uri.clone(), version: 2, }, content_changes: changes, }) .await; server .get_document_content(&uri) .await .expect("document should be open") } fn ranged_change(start: (u32, u32), end: (u32, u32), text: &str) -> TextDocumentContentChangeEvent { TextDocumentContentChangeEvent { range: Some(Range { start: Position { line: start.0, character: start.1, }, end: Position { line: end.0, character: end.1, }, }), range_length: None, text: text.to_string(), } } fn full_change(text: &str) -> TextDocumentContentChangeEvent { TextDocumentContentChangeEvent { range: None, range_length: None, text: text.to_string(), } } #[tokio::test] async fn test_did_change_applies_ranged_changes_in_order() { // The second change's positions refer to the document after the first. let content = content_after_changes( "# Title\n\nHello world\n", vec![ ranged_change((2, 6), (2, 11), "rumdl"), ranged_change((0, 2), (0, 7), "Doc"), ], ) .await; assert_eq!(content, "# Doc\n\nHello rumdl\n"); } #[tokio::test] async fn test_did_change_ranged_positions_count_utf16_code_units() { // The emoji is two UTF-16 code units and four UTF-8 bytes. let content = content_after_changes("# ๐Ÿ˜€ Title\n", vec![ranged_change((0, 5), (0, 10), "Name")]).await; assert_eq!(content, "# ๐Ÿ˜€ Name\n"); } #[tokio::test] async fn test_did_change_ranged_insert_across_lines_and_at_end() { let content = content_after_changes( "# A\r\n\r\nB\r\n", vec![ ranged_change((0, 3), (2, 0), "\r\n\r\nC\r\n\r\n"), // Past the last line: clamps to the end of the document. ranged_change((9, 0), (9, 0), "D\n"), ], ) .await; assert_eq!(content, "# A\r\n\r\nC\r\n\r\nB\r\nD\n"); } #[tokio::test] async fn test_did_change_last_full_change_wins() { let content = content_after_changes("# A\n", vec![full_change("# B\n"), full_change("# C\n")]).await; assert_eq!(content, "# C\n"); } #[tokio::test] async fn test_did_change_full_then_ranged_change() { let content = content_after_changes( "# A\n", vec![full_change("# B\n\nText\n"), ranged_change((2, 0), (2, 4), "Body")], ) .await; assert_eq!(content, "# B\n\nBody\n"); } // ========================================================================= // Source files an editor hands over are not Markdown // ========================================================================= /// Swift whose directives a Markdown fixer turns into headings. const SWIFT_SOURCE: &str = "#if DEBUG\nlet x = 1\n#endif \n"; async fn open_in_memory(server: &RumdlLanguageServer, uri: &Url, text: &str) { server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.to_string(), version: Some(1), from_disk: false, }, ); } /// The editor's formatting edits for `uri`. async fn formatting_edits(server: &RumdlLanguageServer, uri: &Url) -> Vec { server .formatting(DocumentFormattingParams { text_document: TextDocumentIdentifier { uri: uri.clone() }, options: editor_formatting_options(), work_done_progress_params: WorkDoneProgressParams::default(), }) .await .unwrap() .expect("an open document is formatted") } #[tokio::test] async fn test_source_files_get_no_diagnostics_fixes_or_formatting() { let server = create_test_server(); let whole = Range::new(Position::new(0, 0), Position::new(3, 0)); // The same bytes in a Markdown file: the server reports and rewrites them, // so the empty results below are the gate, not text with nothing to say. let markdown = Url::from_file_path(test_temp_path("source_gate").join("a.md")).unwrap(); open_in_memory(&server, &markdown, SWIFT_SOURCE).await; assert!( !server .lint_document(&markdown, SWIFT_SOURCE, true) .await .unwrap() .is_empty() ); assert!(server.apply_all_fixes(&markdown, SWIFT_SOURCE).await.unwrap().is_some()); assert!(!formatting_edits(&server, &markdown).await.is_empty()); assert!( !server .get_code_actions(&markdown, SWIFT_SOURCE, whole) .await .unwrap() .is_empty() ); // Rust is included: the server reads no doc comments, and the Rust source // read as Markdown is the same noise. for name in ["a.swift", "Main.kt", "lib.rs"] { let uri = Url::from_file_path(test_temp_path("source_gate").join(name)).unwrap(); open_in_memory(&server, &uri, SWIFT_SOURCE).await; assert!( server.lint_document(&uri, SWIFT_SOURCE, true).await.unwrap().is_empty(), "{name}" ); assert!( server.apply_all_fixes(&uri, SWIFT_SOURCE).await.unwrap().is_none(), "{name}" ); assert!(formatting_edits(&server, &uri).await.is_empty(), "{name}"); assert!( server .get_code_actions(&uri, SWIFT_SOURCE, whole) .await .unwrap() .is_empty(), "{name}" ); } } #[tokio::test] async fn test_an_open_source_file_is_not_indexed_as_a_link_target() { use std::fs; use tempfile::tempdir; use tower_lsp::LanguageServer; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let server = create_test_server(); *server.workspace_roots.write().await = vec![root.clone()]; assert!(server.queue_index_update(IndexUpdate::FullRescan).await); wait_for_index_ready(&server).await; let source = root.join("a.swift"); let markdown = root.join("a.md"); // A heading either file would contribute if it were indexed. let text = "# Title\n"; fs::write(&source, text).unwrap(); fs::write(&markdown, text).unwrap(); for path in [&source, &markdown] { server .did_open(DidOpenTextDocumentParams { text_document: TextDocumentItem { uri: Url::from_file_path(path).unwrap(), language_id: "markdown".to_string(), version: 1, text: text.to_string(), }, }) .await; } // The Markdown file, queued after the source file, shows the worker has // flushed both. wait_for_index_entry(&server, &markdown, |file| !file.headings.is_empty()).await; assert!(server.workspace_index.read().await.get_file(&source).is_none()); } #[path = "../../tests/support/native_tool.rs"] mod native_code_block_tool; fn lsp_tool_project(extra: &str, mode: &str) -> (tempfile::TempDir, Url) { let dir = tempfile::tempdir().unwrap(); native_code_block_tool::install(dir.path(), mode); std::fs::write(dir.path().join("pyproject.toml"), "").unwrap(); std::fs::write( dir.path().join(".rumdl.toml"), format!( r#" [code-block-tools] enabled = true on-no-tools-run = "fail" binary-preferences = {{ rumdl-policy-test = "project" }} {extra} [code-block-tools.tools.test] command = ["rumdl-policy-test"] stdin = true stdout = true [code-block-tools.languages] python = {{ lint = ["test"] }} "# ), ) .unwrap(); let path = dir.path().join("t.md"); std::fs::write(&path, "").unwrap(); let uri = Url::from_file_path(&path).unwrap(); (dir, uri) } #[tokio::test] async fn code_block_policies_run_on_save_but_not_on_keystrokes() { let (dir, uri) = lsp_tool_project("on-unknown-language-tag = \"fail\"", "count"); let server = create_test_server(); let text = "# Test\n\n```pyhton\nx\n```\n\n```python\nx\n```\n"; let typed = server.lint_document(&uri, text, false).await.unwrap(); assert!(!dir.path().join("calls").exists()); assert!( !typed .iter() .any(|d| d.message.contains("Unrecognized") || d.message.contains("No tools executed")) ); let saved = server.lint_document(&uri, text, true).await.unwrap(); assert!( saved .iter() .any(|d| d.message.contains("Unrecognized code block language")), "{saved:?}" ); assert!( !saved.iter().any(|d| d.message.contains("No tools executed")), "{saved:?}" ); assert_eq!(std::fs::read_to_string(dir.path().join("calls")).unwrap(), "ran\n"); assert_eq!(std::fs::read_to_string(dir.path().join("t.md")).unwrap(), ""); } #[tokio::test] async fn code_block_save_uses_project_native_binary_on_each_requested_check() { let (dir, uri) = lsp_tool_project("", "count"); let server = create_test_server(); let text = "# Test\n\n```python\nx\n```\n"; for _ in 0..2 { let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); assert!( !diagnostics .iter() .any(|d| d.message.contains("No tools executed") || d.message.contains("not found")), "{diagnostics:?}" ); } assert_eq!(std::fs::read_to_string(dir.path().join("calls")).unwrap(), "ran\nran\n"); } #[tokio::test] async fn code_block_save_reports_block_coverage_and_fail_fast_stops_valid_blocks() { let (dir, uri) = lsp_tool_project("on-missing-language-tag = \"fail-fast\"", "count"); let server = create_test_server(); let text = "# Test\n\n```\nx\n```\n\n```python\nx\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); assert!( diagnostics.iter().any(|d| d.message.contains("no language tag")), "{diagnostics:?}" ); assert!( !diagnostics.iter().any(|d| d.message.contains("No tools executed")), "{diagnostics:?}" ); assert!(!dir.path().join("calls").exists()); } #[tokio::test] async fn code_block_lsp_only_system_preference_rejects_project_only_tool() { let (dir, uri) = lsp_tool_project("on-missing-tool-binary = \"fail\"", "count"); let config = dir.path().join(".rumdl.toml"); std::fs::write( &config, std::fs::read_to_string(&config) .unwrap() .replace("rumdl-policy-test = \"project\"", "rumdl-policy-test = \"only-system\""), ) .unwrap(); let server = create_test_server(); let text = "# Test\n\n```python\nx\n```\n"; let diagnostics = server.lint_document(&uri, text, true).await.unwrap(); assert!( diagnostics.iter().any(|d| d.message.contains("not found")), "{diagnostics:?}" ); assert!(!dir.path().join("calls").exists()); } #[tokio::test] async fn code_block_invocation_policy_does_not_flag_automatic_prose_checks() { let (_dir, uri) = lsp_tool_project("", "count"); let server = create_test_server(); for external in [false, true] { let diagnostics = server.lint_document(&uri, "# Clean\n", external).await.unwrap(); assert!( !diagnostics.iter().any(|d| d.message.contains("No tools executed")), "{diagnostics:?}" ); } } #[tokio::test] async fn test_cli2_nested_inheritance_aliases_and_ignores_use_workspace_scope() { use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let root = temp.path().resolve_like_server(); let docs = root.join("docs"); let user = root.join("xdg"); fs::create_dir_all(&docs).unwrap(); fs::create_dir_all(&user).unwrap(); fs::write( root.join(".markdownlint-cli2.yaml"), "config:\n MD013:\n line_length: 100\nignores:\n - docs/root.md\n", ) .unwrap(); fs::write( docs.join(".markdownlint-cli2.yaml"), "config:\n line-length:\n line_length: 120\nignores:\n - nested.md\n", ) .unwrap(); let file = docs.join("nested.md"); fs::write(&file, "# T\n\ntext \n").unwrap(); let server = create_test_server(); server.workspace_roots.write().await.push(root.clone()); // HOME == workspace root: both the workspace config and nested config apply. let config = server .resolve_config_for_file_impl(&file, Some(&user), Some(&root)) .await; assert_eq!( crate::config::get_rule_config_value::(&config, "MD013", "line-length"), Some(120) ); assert!(config.is_cli2_ignored(&file)); assert!(config.is_cli2_ignored(&docs.join("root.md"))); assert!(!config.is_cli2_ignored(&docs.join("keep.md"))); let uri = Url::from_file_path(&file).unwrap(); // The cache populated above must carry ignores into diagnostics and formatting. assert!( server .lint_document(&uri, "# T\n\ntext \n", false) .await .unwrap() .is_empty() ); } #[tokio::test] async fn test_cli2_root_ignores_survive_native_document_config() { use std::fs; let temp = tempfile::tempdir().unwrap(); let root = temp.path().resolve_like_server(); let docs = root.join("docs"); let user = root.join("xdg"); fs::create_dir_all(&docs).unwrap(); fs::create_dir_all(&user).unwrap(); fs::write( root.join(".markdownlint-cli2.yaml"), "ignores:\n - docs/generated/**\n", ) .unwrap(); fs::write(docs.join(".rumdl.toml"), "[global]\nenable = [\"MD009\"]\n").unwrap(); let file = docs.join("generated/unsaved.md"); let server = create_test_server(); server.workspace_roots.write().await.push(root.clone()); let config = server .resolve_config_for_file_impl(&file, Some(&user), Some(&root)) .await; assert!(config.is_cli2_ignored(&file)); assert!(!config.is_cli2_ignored(&docs.join("keep.md"))); let uri = Url::from_file_path(&file).unwrap(); assert!( server .lint_document(&uri, "# T\n\ntext \n", false) .await .unwrap() .is_empty() ); let text = "# T\n\ntext "; server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.into(), version: Some(1), from_disk: false, }, ); let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }; let (original, formatted) = server.format_document(&uri, &options).await.unwrap(); assert_eq!(original, text); assert_eq!(formatted, text); } #[tokio::test] async fn test_explicit_cli2_ignores_use_workspace_root() { let temp = tempfile::tempdir().unwrap(); let root = temp.path().resolve_like_server(); let path = root.join(".markdownlint-cli2.yaml"); std::fs::write(&path, "ignores:\n - docs/**\n").unwrap(); let server = create_test_server_with_cli_config(path.to_str().unwrap()); server.workspace_roots.write().await.push(root.clone()); server.load_configuration(false).await; let file = root.join("docs/unsaved.md"); let config = server.resolve_config_for_file(&file).await; assert!(config.is_cli2_ignored(&file)); let uri = Url::from_file_path(&file).unwrap(); let text = "# T\n\ntext "; assert!(server.lint_document(&uri, text, false).await.unwrap().is_empty()); assert!( server .get_code_actions(&uri, text, Range::new(Position::new(0, 0), Position::new(3, 0))) .await .unwrap() .is_empty() ); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.into(), version: Some(1), from_disk: false, }, ); let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }; let (original, formatted) = server.format_document(&uri, &options).await.unwrap(); assert_eq!(original, text); assert_eq!(formatted, text); } #[cfg(unix)] #[tokio::test] async fn test_cli2_ignores_preserve_symlink_directory_spelling() { let temp = tempfile::tempdir().unwrap(); let target = tempfile::tempdir().unwrap(); let root = temp.path().resolve_like_server(); std::fs::write( root.join(".markdownlint-cli2.yaml"), "config:\n MD013:\n line_length: 100\nignores:\n - docs/**\n", ) .unwrap(); std::fs::write( target.path().join(".markdownlint-cli2.yaml"), "config:\n MD041: false\n", ) .unwrap(); std::os::unix::fs::symlink(target.path(), root.join("docs")).unwrap(); let server = create_test_server(); server.workspace_roots.write().await.push(root.clone()); server.load_configuration(false).await; let file = root.join("docs/unsaved.md"); let config = server.resolve_config_for_file(&file).await; assert_eq!( crate::config::get_rule_config_value::(&config, "MD013", "line-length"), Some(100) ); assert!(config.is_cli2_ignored(&file)); let uri = Url::from_file_path(&file).unwrap(); let text = "# T\n\ntext "; assert!(server.lint_document(&uri, text, false).await.unwrap().is_empty()); server.documents.write().await.insert( uri.clone(), DocumentEntry { content: text.into(), version: Some(1), from_disk: false, }, ); let options = FormattingOptions { tab_size: 4, insert_spaces: true, properties: HashMap::new(), trim_trailing_whitespace: Some(true), insert_final_newline: Some(true), trim_final_newlines: Some(true), }; let (_, formatted) = server.format_document(&uri, &options).await.unwrap(); assert_eq!(formatted, text); } #[test] fn test_lsp_config_walk_stops_at_the_profile_boundary() { // The user profile, when it is a home in its own right next to the resolved home, // is user-level exactly like the home: its dotfile is not a project config. use std::fs; use tempfile::tempdir; let temp = tempdir().unwrap(); let fake_home = temp.path().join("home"); let profile = temp.path().join("profile"); let nested = profile.join("notes").join("subdir"); let project = profile.join("proj"); fs::create_dir_all(&fake_home).unwrap(); fs::create_dir_all(&nested).unwrap(); fs::create_dir_all(project.join("docs")).unwrap(); fs::write(profile.join(".rumdl.toml"), "[global]\ndisable = [\"MD041\"]\n").unwrap(); fs::write(project.join(".rumdl.toml"), "[global]\ndisable = [\"MD013\"]\n").unwrap(); let candidates = crate::config::collect_project_config_candidates_bounded(&nested, None, Some(&fake_home), Some(&profile)); assert!( candidates.is_empty(), "The profile dotfile must not be discovered as a project config, got: {candidates:?}" ); let control = crate::config::collect_project_config_candidates_bounded( &project.join("docs"), None, Some(&fake_home), Some(&profile), ); assert_eq!(control.first(), Some(&project.join(".rumdl.toml"))); let workspace_is_profile = crate::config::collect_project_config_candidates_bounded( &nested, Some(&profile), Some(&fake_home), Some(&profile), ); assert_eq!( workspace_is_profile.first(), Some(&profile.join(".rumdl.toml")), "A workspace opened at the profile keeps its own config" ); } /// A server that runs MD048 alone, enforcing `style`. async fn md048_server(style: &str) -> RumdlLanguageServer { let server = create_test_server(); let mut config = crate::config::Config::default(); config.global.enable = vec!["MD048".into()]; config .rules .entry("MD048".into()) .or_default() .values .insert("style".into(), toml::Value::String(style.into())); *server.rumdl_config.write().await = config; server } /// The MD048 fix actions a client is offered with the cursor on `line`. async fn md048_quick_fixes(server: &RumdlLanguageServer, uri: &Url, text: &str, line: u32) -> Vec { let cursor = Position::new(line, 0); server .get_code_actions(uri, text, Range::new(cursor, cursor)) .await .unwrap() .into_iter() .filter(|action| { action.kind == Some(CodeActionKind::QUICKFIX) && action.title.starts_with("Fix: ") && action .diagnostics .iter() .flatten() .any(|diagnostic| diagnostic.code == Some(NumberOrString::String("MD048".into()))) }) .collect() } /// Apply one code action the way a client does: every edit addresses the /// document the action was computed for, and no two of them may overlap. fn apply_code_action(action: &CodeAction, uri: &Url, text: &str) -> String { let mut edits: Vec<_> = action.edit.as_ref().unwrap().changes.as_ref().unwrap()[uri] .iter() .map(|edit| { let start = crate::lsp::position::lsp_position_to_byte_offset(text, edit.range.start); let end = crate::lsp::position::lsp_position_to_byte_offset(text, edit.range.end); (start, end, edit.new_text.as_str()) }) .collect(); edits.sort_by_key(|&(start, end, _)| (start, end)); let mut result = String::new(); let mut copied = 0; for (start, end, new_text) in edits { assert!(copied <= start && start <= end, "overlapping edits in {action:?}"); result.push_str(&text[copied..start]); result.push_str(new_text); copied = end; } result.push_str(&text[copied..]); result } /// MD048 reports the two fences of a block as separate diagnostics. The quick /// fix of either one must rewrite both fences: a fence converted on its own no /// longer pairs with the other, and the block runs on over the prose after it. #[tokio::test] async fn md048_quick_fix_on_either_fence_converts_both_fences_of_the_block() { let uri = Url::parse("untitled:fences.md").unwrap(); // Style, document, the document with the first block converted, and the // 0-indexed lines of that block's opening and closing fence. let cases: [(&str, &str, &str, u32, u32); 8] = [ ( "backtick", "Before.\n\n~~~text\ncode\n~~~\n\nAfter.\n", "Before.\n\n```text\ncode\n```\n\nAfter.\n", 2, 4, ), ( "tilde", "Before.\n\n```text\ncode\n```\n\nAfter.\n", "Before.\n\n~~~text\ncode\n~~~\n\nAfter.\n", 2, 4, ), // The converted fences are lengthened past the inner ones. ( "backtick", "~~~markdown\n```rust\ncode\n```\n~~~\n\nAfter.\n", "````markdown\n```rust\ncode\n```\n````\n\nAfter.\n", 0, 4, ), ( "tilde", "```markdown\n~~~~\ncode\n~~~~\n```\n\nAfter.\n", "~~~~~markdown\n~~~~\ncode\n~~~~\n~~~~~\n\nAfter.\n", 0, 4, ), // A block in a list item, its closing fence indented differently. ( "backtick", "- item\n\n ~~~text\n code\n ~~~\n\n After.\n", "- item\n\n ```text\n code\n ```\n\n After.\n", 2, 4, ), // Only the block under the cursor is converted. ( "backtick", "~~~text\none\n~~~\n\n~~~text\ntwo\n~~~\n", "```text\none\n```\n\n~~~text\ntwo\n~~~\n", 0, 2, ), // Characters wider than one byte or one UTF-16 unit, before and on the fence line. ( "backtick", "รœnรฏ ๐ŸŽ‰ cรถdรฉ.\n\n~~~~ๅ†…ๅฎน ๐ŸŽ‰\ncode ๐ŸŽ‰\n~~~~~ \n\nAfter ๐ŸŽ‰.\n", "รœnรฏ ๐ŸŽ‰ cรถdรฉ.\n\n````ๅ†…ๅฎน ๐ŸŽ‰\ncode ๐ŸŽ‰\n```` \n\nAfter ๐ŸŽ‰.\n", 2, 4, ), // The closing fence ends the document. ("backtick", "~~~text\ncode\n~~~", "```text\ncode\n```", 0, 2), ]; for (style, document, converted, opener, closer) in cases { let server = md048_server(style).await; for (text, expected) in [ (document.to_string(), converted.to_string()), (document.replace('\n', "\r\n"), converted.replace('\n', "\r\n")), ] { for line in [opener, closer] { let actions = md048_quick_fixes(&server, &uri, &text, line).await; assert_eq!( actions.len(), 1, "one MD048 fix on line {line} of {text:?}: {actions:?}" ); // Each diagnostic stays on its own fence. let diagnostics = actions[0].diagnostics.as_ref().unwrap(); assert_eq!(diagnostics.len(), 1); assert_eq!(diagnostics[0].range.start.line, line); assert_eq!(diagnostics[0].range.end.line, line); let fixed = apply_code_action(&actions[0], &uri, &text); assert_eq!( fixed, expected, "the quick fix on line {line} of {text:?} must convert both fences" ); } } } } /// The edits of a paired MD048 quick fix address whole fence lines in UTF-16 /// units, whichever fence the action was requested on. #[tokio::test] async fn md048_quick_fix_edits_address_both_fence_lines_in_utf16_units() { let server = md048_server("backtick").await; let uri = Url::parse("untitled:fences.md").unwrap(); for ending in ["\n", "\r\n"] { let text = "รœnรฏ ๐ŸŽ‰ cรถdรฉ.\n\n~~~ๅ†…ๅฎน ๐ŸŽ‰\ncode ๐ŸŽ‰\n~~~\n\nAfter ๐ŸŽ‰.\n".replace('\n', ending); for line in [2, 4] { let actions = md048_quick_fixes(&server, &uri, &text, line).await; assert_eq!(actions.len(), 1, "{actions:?}"); let mut edits = actions[0].edit.as_ref().unwrap().changes.as_ref().unwrap()[&uri].clone(); edits.sort_by_key(|edit| edit.range.start.line); assert_eq!( edits, [ TextEdit { // `~~~ๅ†…ๅฎน ๐ŸŽ‰`: three tildes, two ideographs, a space, a surrogate pair. range: Range::new(Position::new(2, 0), Position::new(2, 8)), new_text: "```ๅ†…ๅฎน ๐ŸŽ‰".into(), }, TextEdit { range: Range::new(Position::new(4, 0), Position::new(4, 3)), new_text: "```".into(), }, ], "line {line} of {text:?}" ); } } } /// Fix-all and formatting collect the fixes of both diagnostics of a block. /// Each fence is still rewritten exactly once. #[tokio::test] async fn md048_fix_all_rewrites_each_fence_of_a_block_once() { let uri = Url::parse("untitled:fences.md").unwrap(); for (style, document, converted) in [ ( "backtick", "~~~text\none\n~~~\n\n~~~markdown\n```rust\ntwo\n```\n~~~\n\n- item\n\n ~~~text\n three\n ~~~\n\nAfter ๐ŸŽ‰.\n", "```text\none\n```\n\n````markdown\n```rust\ntwo\n```\n````\n\n- item\n\n ```text\n three\n ```\n\nAfter ๐ŸŽ‰.\n", ), ( "tilde", "```text\none\n```\n\n```markdown\n~~~~\ntwo\n~~~~\n```\n\nAfter ๐ŸŽ‰.\n", "~~~text\none\n~~~\n\n~~~~~markdown\n~~~~\ntwo\n~~~~\n~~~~~\n\nAfter ๐ŸŽ‰.\n", ), ] { let server = md048_server(style).await; for (text, expected) in [ (document.to_string(), converted.to_string()), (document.replace('\n', "\r\n"), converted.replace('\n', "\r\n")), ] { assert_eq!(fix_all_text(&server, &uri, &text).await.as_ref(), Some(&expected)); assert_eq!( server.apply_all_fixes(&uri, &text).await.unwrap().as_ref(), Some(&expected) ); assert_eq!(fix_all_text(&server, &uri, &expected).await, None); } } } /// Blocks MD048 offers no paired conversion for keep the actions they had. #[tokio::test] async fn md048_quick_fix_leaves_unpaired_and_exempt_fences_as_they_were() { let server = md048_server("backtick").await; let uri = Url::parse("untitled:fences.md").unwrap(); // A directive on the opening fence exempts the block: no fix on either fence. for text in [ "\n~~~text\ncode\n~~~\n\nAfter.\n", "\n~~~text\ncode\n~~~\n\n\nAfter.\n", ] { for line in [1, 3] { let actions = md048_quick_fixes(&server, &uri, text, line).await; assert!(actions.is_empty(), "line {line} of {text:?}: {actions:?}"); } assert_eq!(fix_all_text(&server, &uri, text).await, None); } // The block after an exempt one is still converted as a pair. let text = "\n~~~text\none\n~~~\n\n~~~text\ntwo\n~~~\n"; let expected = "\n~~~text\none\n~~~\n\n```text\ntwo\n```\n"; assert_eq!(fix_all_text(&server, &uri, text).await.as_deref(), Some(expected)); // An info string a backtick fence cannot carry: reported, never converted. let text = "~~~foo `bar`\ncode\n~~~\n\nAfter.\n"; for line in [0, 2] { let actions = md048_quick_fixes(&server, &uri, text, line).await; assert!(actions.is_empty(), "line {line} of {text:?}: {actions:?}"); } // An unclosed block has one fence to convert, lengthened past its content. let text = "Before.\n\n~~~text\n```\ncode\n"; let actions = md048_quick_fixes(&server, &uri, text, 2).await; assert_eq!(actions.len(), 1, "{actions:?}"); assert_eq!( actions[0].edit.as_ref().unwrap().changes.as_ref().unwrap()[&uri].len(), 1 ); assert_eq!( apply_code_action(&actions[0], &uri, text), "Before.\n\n````text\n```\ncode\n" ); }