Update README for performance metrics, enhance find command output, and add comprehensive tests for link and reference functionalities

Author: StudentWeis

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mdref"
-version = "0.3.5"
+version = "0.3.6"
 edition = "2024"
 authors = ["Student Wei <studentweis@gmail.com>"]
 repository = "https://github.com/studentweis/mdref"

Cargo.toml

@@ -2,7 +2,7 @@
 
 [![crates.io](https://img.shields.io/crates/v/mdref.svg)](https://crates.io/crates/mdref)
 
-A fast, Rust-based tool for discovering and migrating Markdown references — it processed 155 directories and 1,561 files in just 1 ms.
+A fast, Rust-based tool for discovering and migrating Markdown references — it processed 155 directories and 1,561 files in just 0.1 seconds. Support search by file or directory.
 
 > [!CAUTION]
 > This project is still in early development, and some features may not be fully functional. Please use it with caution and report any issues you encounter.
@@ -14,13 +14,13 @@ A fast, Rust-based tool for discovering and migrating Markdown references — it
 Install prebuilt binaries via shell script：
 
 ```sh
-curl --proto '=https' --tlsv1.2 -LsSf https://github.com/studentweis/mdref/releases/download/0.3.5/mdref-installer.sh | sh
+curl --proto '=https' --tlsv1.2 -LsSf https://github.com/studentweis/mdref/releases/download/0.3.6/mdref-installer.sh | sh
 ```
 
 Install prebuilt binaries via powershell script
 
 ```sh
-powershell -ExecutionPolicy Bypass -c "irm https://github.com/studentweis/mdref/releases/download/0.3.5/mdref-installer.ps1 | iex"
+powershell -ExecutionPolicy Bypass -c "irm https://github.com/studentweis/mdref/releases/download/0.3.6/mdref-installer.ps1 | iex"
 ```
 
 Update mdref:
@@ -58,12 +58,13 @@ Links in ./examples/main.md:
 
 # Todo
 
+- [ ] More tests.
+- [ ] Directory path support.
 - [ ] Fix the case of link path with space.
+- [ ] VSCode extension.
 - [ ] Preview mode of mv command.
-- [ ] More tests.
 - [ ] More documentations.
 - [ ] Cargo-dist oranda homepage.
-- [ ] VSCode extension.
 
 # Acknowledge
 

README.md

@@ -3,6 +3,8 @@ use mdref::{Result, find_links, find_references};
 pub fn run(file_path: String, root_dir: Option<String>) -> Result<()> {
     let root_path = root_dir.unwrap_or_else(|| ".".to_string());
 
+    println!("-------------------------------");
+
     // Find references to the specified file.
     let references = find_references(&file_path, &root_path)?;
     if references.is_empty() {
@@ -14,6 +16,8 @@ pub fn run(file_path: String, root_dir: Option<String>) -> Result<()> {
         }
     }
 
+    println!("-------------------------------");
+
     // Find all links within the specified file.
     let links = find_links(&file_path)?;
     if links.is_empty() {
@@ -25,5 +29,7 @@ pub fn run(file_path: String, root_dir: Option<String>) -> Result<()> {
         }
     }
 
+    println!("-------------------------------");
+
     Ok(())
 }

src/commands/find.rs

@@ -77,41 +77,76 @@ fn process_md_file(
 /// Determine whether a markdown link (found in `file_path`) refers to `target_canonical`.
 ///
 /// - If `target_canonical` is `None`, this function returns `true` (used when simply collecting links).
-/// - If `Some(target)`, the link is considered a match only when:
-///   1. The file name component of the link equals the target's file name, and
-///   2. Resolving the link relative to `file_path` and canonicalizing it yields the same absolute path as `target`.
+/// - If `Some(target)`, the link is considered a match if:
+///   - For files: the file name matches and the resolved path equals the target.
+///   - For directories: the resolved path is inside the target directory.
 ///
-/// Returns `true` when both checks succeed; otherwise `false`.
+/// Returns `true` when the checks succeed; otherwise `false`.
 fn process_link(file_path: &Path, target_canonical: Option<&Path>, link: &str) -> bool {
-    if let Some(target) = target_canonical {
+    // If no target specified, accept all links (used for collecting all links)
+    let target = match target_canonical {
+        Some(t) => t,
+        None => return true,
+    };
+
+    // Early check: if target is a file, the link's filename must match
+    if target.is_file() {
         let link_path = Path::new(link);
-        // Check if filenames match
-        if link_path.file_name().unwrap() != target.file_name().unwrap() {
+        if link_path.file_name() != target.file_name() {
             return false;
         }
-        // Check if absolute paths match
-        if let Some(resolved_path) = resolve_link(file_path, link_path) {
-            matches!(resolved_path.canonicalize(), Ok(canonical) if canonical == *target)
-        } else {
-            false
-        }
+    }
+
+    // Resolve and canonicalize the link path
+    let canonical_link = match resolve_and_canonicalize_link(file_path, link) {
+        Some(path) => path,
+        None => return false,
+    };
+
+    // Match the link against the target
+    match_link_to_target(&canonical_link, target)
+}
+
+/// Resolve a link path and canonicalize it.
+///
+/// Returns `None` if the link cannot be resolved or canonicalized.
+fn resolve_and_canonicalize_link(base_file: &Path, link: &str) -> Option<PathBuf> {
+    let link_path = Path::new(link);
+    let resolved = resolve_link(base_file, link_path)?;
+    resolved.canonicalize().ok()
+}
+
+/// Check if a canonicalized link matches the target path.
+///
+/// For files: the canonical path must match (filename check already done earlier).
+/// For directories: the link must resolve to a path inside the target directory.
+fn match_link_to_target(canonical_link: &Path, target: &Path) -> bool {
+    if target.is_file() {
+        // Filename already checked, just compare canonical paths
+        canonical_link == target
+    } else if target.is_dir() {
+        canonical_link.starts_with(target)
     } else {
-        true
+        false
     }
 }
 
-/// Resolve a link relative to the base file path and root directory.
+/// Resolve a link relative to the base file path.
+///
+/// Handles both absolute and relative links.
+/// For relative links, resolves them relative to the base file's parent directory.
 fn resolve_link(base_path: &Path, link_path: &Path) -> Option<PathBuf> {
     if link_path.is_absolute() {
-        Some(link_path.to_path_buf())
+        return Some(link_path.to_path_buf());
+    }
+
+    // Resolve relative to the base file's directory
+    let parent = base_path.parent()?;
+    let resolved = parent.join(link_path);
+
+    if resolved.exists() {
+        Some(resolved)
     } else {
-        // Try relative to the file's directory first
-        if let Some(parent) = base_path.parent() {
-            let resolved = parent.join(link_path);
-            if resolved.exists() {
-                return Some(resolved);
-            }
-        }
         None
     }
 }

src/core/find.rs

@@ -1,21 +1,169 @@
-use mdref::{find_links, find_references};
+use mdref::{find_links, find_references, Reference};
+use std::path::Path;
+
+// ============= find_links tests =============
 
 #[test]
 fn test_find_links_nonexistent_file() {
-    let result = find_links(std::path::Path::new("nonexistent.md"));
+    let result = find_links(Path::new("nonexistent.md"));
     assert!(result.is_err());
 }
 
 #[test]
 fn test_find_links_basic() {
-    let path = std::path::Path::new("examples/main.md");
+    let path = Path::new("examples/main.md");
     let result = find_links(path).unwrap();
     assert!(!result.is_empty());
 }
 
+#[test]
+fn test_find_links_non_markdown_file() {
+    // Non-markdown files should return an empty Vec
+    let path = Path::new("Cargo.toml");
+    let result = find_links(path).unwrap();
+    assert!(result.is_empty());
+}
+
+#[test]
+fn test_find_links_count() {
+    let path = Path::new("examples/main.md");
+    let result = find_links(path).unwrap();
+    // main.md should have 8 links (including image links)
+    assert_eq!(result.len(), 8);
+}
+
+#[test]
+fn test_find_links_content_verification() {
+    let path = Path::new("examples/main.md");
+    let result = find_links(path).unwrap();
+    
+    // Verify the found links
+    let link_texts: Vec<&str> = result.iter().map(|r| r.link_text.as_str()).collect();
+    assert!(link_texts.contains(&"main.md"));
+    assert!(link_texts.contains(&"inner/main.md"));
+    assert!(link_texts.contains(&"other.md"));
+}
+
+#[test]
+fn test_find_links_line_numbers() {
+    let path = Path::new("examples/main.md");
+    let result = find_links(path).unwrap();
+    
+    // Verify that line numbers are correct (greater than 0)
+    for reference in result {
+        assert!(reference.line > 0);
+        assert!(reference.column > 0);
+    }
+}
+
+// ============= find_references tests =============
+
 #[test]
 fn test_find_references_basic() {
-    let path = std::path::Path::new("examples/main.md");
+    let path = Path::new("examples/main.md");
     let result = find_references(path, path.parent().unwrap()).unwrap();
     assert_eq!(result.len(), 6)
 }
+
+#[test]
+fn test_find_references_nonexistent_file() {
+    let path = Path::new("nonexistent.md");
+    let root = Path::new("examples");
+    let result = find_references(path, root);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_find_references_other_md() {
+    let path = Path::new("examples/other.md");
+    let result = find_references(path, path.parent().unwrap()).unwrap();
+    // other.md is referenced once by main.md
+    assert!(!result.is_empty());
+}
+
+#[test]
+fn test_find_references_inner_main() {
+    let path = Path::new("examples/inner/main.md");
+    let root = Path::new("examples");
+    let result = find_references(path, root).unwrap();
+    // inner/main.md is referenced by the outer main.md and other.md
+    assert!(result.len() >= 2);
+}
+
+#[test]
+fn test_find_references_empty_directory() {
+    let path = Path::new("examples/main.md");
+    // Use a directory that should have no references
+    let root = Path::new("benches");
+    let result = find_references(path, root).unwrap();
+    // The benches directory should have no references to examples/main.md
+    assert_eq!(result.len(), 0);
+}
+
+#[test]
+fn test_find_references_returns_correct_paths() {
+    let path = Path::new("examples/main.md");
+    let result = find_references(path, path.parent().unwrap()).unwrap();
+    
+    // Verify that the returned paths are all markdown files
+    for reference in result {
+        assert_eq!(reference.path.extension().and_then(|s| s.to_str()), Some("md"));
+    }
+}
+
+// ============= Reference struct tests =============
+
+#[test]
+fn test_reference_creation() {
+    let reference = Reference::new(
+        std::path::PathBuf::from("test.md"),
+        10,
+        5,
+        "link.md".to_string()
+    );
+    
+    assert_eq!(reference.line, 10);
+    assert_eq!(reference.column, 5);
+    assert_eq!(reference.link_text, "link.md");
+}
+
+#[test]
+fn test_reference_display() {
+    let reference = Reference::new(
+        std::path::PathBuf::from("test.md"),
+        10,
+        5,
+        "link.md".to_string()
+    );
+    
+    let display_str = format!("{}", reference);
+    assert!(display_str.contains("test.md"));
+    assert!(display_str.contains("10"));
+    assert!(display_str.contains("5"));
+    assert!(display_str.contains("link.md"));
+}
+
+// ============= Edge case tests =============
+
+#[test]
+fn test_find_links_empty_markdown_file() {
+    // Create a temporary empty file for testing
+    use std::fs;
+    use std::io::Write;
+    
+    let temp_file = "test_empty.md";
+    fs::File::create(temp_file).unwrap().write_all(b"").unwrap();
+    
+    let result = find_links(Path::new(temp_file)).unwrap();
+    assert_eq!(result.len(), 0);
+    
+    // Cleanup
+    fs::remove_file(temp_file).ok();
+}
+
+#[test]
+fn test_find_references_with_relative_paths() {
+    let path = Path::new("examples/main.md");
+    let result = find_references(path, "examples").unwrap();
+    assert!(!result.is_empty());
+}