From cd43f4306f84fab02b823ca655aae14f0a59c3f1 Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Sun, 6 Jul 2025 10:51:57 -0400 Subject: [PATCH 1/7] ci: enable GitHub Actions for develop branch - Update test workflow to run on push and PR events for develop branch - Ensures CI/CD runs on feature accumulation branch before merging to main --- .github/workflows/test.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index fa42b00..d3566d0 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,9 +2,9 @@ name: Tests on: push: - branches: [ main ] + branches: [ main, develop ] pull_request: - branches: [ main ] + branches: [ main, develop ] jobs: test: From 4b71bd4074db08fa46ec51a8d026c3df6133839a Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Sun, 6 Jul 2025 11:13:46 -0400 Subject: [PATCH 2/7] =?UTF-8?q?feat:=20add=20note=20rename=20functionality?= =?UTF-8?q?=20with=20automatic=20link=20updates=20=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=E2=94=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add M.rename_note() function that finds and updates all link references - Support both [[note]] and [[note|display]] link formats - Add :MarkdownNotesRename command and or keybinding - Include comprehensive input validation and safety checks - Add extensive test suite covering edge cases - Update documentation with examples and usage --- README.md | 14 +- doc/markdown-notes.txt | 22 ++ lua/markdown-notes/config.lua | 1 + lua/markdown-notes/init.lua | 20 ++ lua/markdown-notes/links.lua | 148 +++++++++- tests/markdown-notes/links_spec.lua | 403 ++++++++++++++++++++++++++++ 6 files changed, 605 insertions(+), 3 deletions(-) create mode 100644 tests/markdown-notes/links_spec.lua diff --git a/README.md b/README.md index 38721ea..013e8bd 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ A simple, configurable markdown note-taking plugin for Neovim with support for d - **Template-based Note Creation**: Create notes with default templates or choose from available templates - **Templates**: Flexible template system with variable substitution (`{{date}}`, `{{time}}`, `{{title}}`, etc.) - **Wiki-style Links**: Create and follow `[[note-name]]` links between notes +- **Note Renaming**: Rename notes and automatically update all references across your vault - **Powerful Search**: Find notes by filename or content, search frontmatter tags with syntax highlighting - **Backlinks**: Discover which notes reference the current note - **Workspaces**: Support for multiple independent note vaults with manual switching @@ -86,6 +87,7 @@ require("markdown-notes").setup({ search_tags = "og", show_backlinks = "ob", follow_link = "gf", + rename_note = "or", }, }) ``` @@ -135,8 +137,12 @@ The plugin uses a simple, predictable workspace system: - **Manual switching**: Use `ow` or commands to switch active workspace - **Persistent**: All operations use the active workspace until you manually switch -### Workspace Management Commands +### Commands +**Note Management:** +- `:MarkdownNotesRename [name]` - Rename current note and update all references (prompts if no name provided) + +**Workspace Management:** - `:MarkdownNotesWorkspaceStatus` - Show current workspace for the buffer - `:MarkdownNotesWorkspacePick` - Pick workspace with fuzzy finder - `:MarkdownNotesWorkspaceSwitch ` - Switch to a workspace directory @@ -222,6 +228,10 @@ Daily notes are automatically created with your `Daily.md` template if it exists - `ob` - Show backlinks to the current note with file preview - Press `Enter` to open the selected note - Press `Ctrl+L` to insert a link to the note +- `or` - Rename the current note and update all references + - Prompts for new name and shows confirmation with file count + - Updates all `[[wiki-links]]` and `[[link|display text]]` references + - Handles files in subdirectories and prevents partial matches ### Templates @@ -290,4 +300,4 @@ Created on {{datetime}} ## License -MIT License - see [LICENSE](LICENSE) file for details. \ No newline at end of file +MIT License - see [LICENSE](LICENSE) file for details. diff --git a/doc/markdown-notes.txt b/doc/markdown-notes.txt index c91e3c6..9da1284 100644 --- a/doc/markdown-notes.txt +++ b/doc/markdown-notes.txt @@ -29,6 +29,7 @@ Features: templating - Templates: Flexible template system with variable substitution - Wiki-style Links: Create and follow `[[note-name]]` links between notes +- Note Renaming: Rename notes and automatically update all references - Powerful Search: Find notes by filename or content, search tags - Backlinks: Discover which notes reference the current note - Workspaces: Support for multiple independent note vaults with manual switching @@ -105,6 +106,7 @@ Default configuration: > search_tags = "og", show_backlinks = "ob", follow_link = "gf", + rename_note = "or", }, }) < @@ -192,6 +194,15 @@ The plugin uses a simple, predictable workspace system: All plugin commands use the currently active workspace configuration. +Commands~ + *markdown-notes-ex-commands* + +Note Management Commands~ + +:MarkdownNotesRename [{name}] *:MarkdownNotesRename* + Rename current note and update all references. If {name} is not provided, + prompts for the new name. Shows confirmation dialog with file count. + Workspace Management Commands~ *markdown-notes-workspace-commands* The following commands are available for workspace management: @@ -246,6 +257,10 @@ Links and Navigation~ - `ob` - Show backlinks to the current note (with file preview) - Press `Enter` to open the selected note - Press `Ctrl+L` to insert a link to the note +- `or` - Rename the current note and update all references + - Prompts for new name and shows confirmation with file count + - Updates all `[[wiki-links]]` and `[[link|display text]]` references + - Handles files in subdirectories and prevents partial matches Templates~ *markdown-notes-templates* @@ -303,6 +318,13 @@ require("markdown-notes.links").follow_link() require("markdown-notes.links").show_backlinks() Show backlinks to the current note. + *markdown-notes.rename_note* +require("markdown-notes.links").rename_note(new_name) + Rename the current note and automatically update all wiki-style link + references across the vault. Supports both `[[note]]` and `[[note|display]]` + formats. Shows confirmation dialog with file count before proceeding. + Handles files in subdirectories and prevents partial matches. + *markdown-notes.pick_template* require("markdown-notes.templates").pick_template() Pick and insert a template at cursor position. diff --git a/lua/markdown-notes/config.lua b/lua/markdown-notes/config.lua index 6705d5a..d7d7908 100644 --- a/lua/markdown-notes/config.lua +++ b/lua/markdown-notes/config.lua @@ -35,6 +35,7 @@ M.defaults = { search_tags = "og", show_backlinks = "ob", follow_link = "gf", + rename_note = "or", pick_workspace = "ow", }, } diff --git a/lua/markdown-notes/init.lua b/lua/markdown-notes/init.lua index 3601a1d..cab5bcd 100644 --- a/lua/markdown-notes/init.lua +++ b/lua/markdown-notes/init.lua @@ -62,6 +62,13 @@ function M.setup_keymaps() map("n", "insert_link", links.search_and_link, "Insert link to note") map("n", "follow_link", links.follow_link, "Follow link") map("n", "show_backlinks", links.show_backlinks, "Show backlinks") + map("n", "rename_note", function() + vim.ui.input({prompt = "New note name: "}, function(input) + if input then + links.rename_note(input) + end + end) + end, "Rename note and update links") -- Templates map("n", "insert_template", templates.pick_template, "Insert template") @@ -72,6 +79,19 @@ function M.setup_keymaps() -- Workspaces map("n", "pick_workspace", workspace.pick_workspace, "Pick workspace") + -- Note management commands + vim.api.nvim_create_user_command("MarkdownNotesRename", function(opts) + if opts.args and opts.args ~= "" then + links.rename_note(opts.args) + else + vim.ui.input({prompt = "New note name: "}, function(input) + if input then + links.rename_note(input) + end + end) + end + end, { nargs = "?", desc = "Rename current note and update links" }) + -- Workspace management commands vim.api.nvim_create_user_command("MarkdownNotesWorkspaceStatus", workspace.show_current_workspace, { desc = "Show current workspace" }) vim.api.nvim_create_user_command("MarkdownNotesWorkspacePick", workspace.pick_workspace, { desc = "Pick workspace with fzf" }) diff --git a/lua/markdown-notes/links.lua b/lua/markdown-notes/links.lua index 2076407..16cb889 100644 --- a/lua/markdown-notes/links.lua +++ b/lua/markdown-notes/links.lua @@ -106,9 +106,14 @@ function M.show_backlinks() local search_text = "[[" .. relative_path .. "]]" -- Get all markdown files first, then check each one - local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*' -printf '%P\\n'" + local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*'" local all_files = vim.fn.systemlist(all_files_cmd) + -- Remove ./ prefix from paths + for i, file in ipairs(all_files) do + all_files[i] = file:gsub("^%./", "") + end + local linked_files = {} for _, file in ipairs(all_files) do local full_path = vault_path .. "/" .. file @@ -152,4 +157,145 @@ function M.show_backlinks() }) end +function M.rename_note(new_name) + local current_path = vim.fn.expand("%:p") + local options = config.get_current_config() + local vault_path = vim.fn.expand(options.vault_path) + + -- Get current note info + local relative_path = current_path:gsub("^" .. vim.pesc(vault_path) .. "/", ""):gsub("%.md$", "") + local current_dir = vim.fn.expand("%:p:h") + + if relative_path == "" then + vim.notify("No current file", vim.log.levels.WARN) + return + end + + -- Validate new name + if not new_name or new_name == "" then + vim.notify("New name cannot be empty", vim.log.levels.ERROR) + return + end + + -- Ensure new_name doesn't have .md extension + new_name = new_name:gsub("%.md$", "") + + -- Check for whitespace-only names + if new_name:match("^%s*$") then + vim.notify("New name cannot be only whitespace", vim.log.levels.ERROR) + return + end + + -- Check for invalid filename characters (basic check) + if new_name:match("[/\\:*?\"<>|]") then + vim.notify("New name contains invalid characters", vim.log.levels.ERROR) + return + end + + -- Create new file path + local new_file_path = current_dir .. "/" .. new_name .. ".md" + + -- Check if target file already exists + if vim.fn.filereadable(new_file_path) == 1 then + vim.notify("File already exists: " .. new_name .. ".md", vim.log.levels.ERROR) + return + end + + -- Find all files that link to this note + local search_text = "[[" .. relative_path .. "]]" + local link_with_display = "%[%[" .. vim.pesc(relative_path) .. "|" + + -- Get all markdown files + local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*'" + local all_files = vim.fn.systemlist(all_files_cmd) + + -- Remove ./ prefix from paths + for i, file in ipairs(all_files) do + all_files[i] = file:gsub("^%./", "") + end + + local files_to_update = {} + local update_count = 0 + + -- Find files with links to update + for _, file in ipairs(all_files) do + local full_path = vault_path .. "/" .. file + local file_content = vim.fn.readfile(full_path) + local content_str = table.concat(file_content, "\n") + local updated = false + + -- Check for exact link matches + if content_str:find(search_text, 1, true) then + updated = true + end + + -- Check for display text links + if content_str:find(link_with_display) then + updated = true + end + + if updated then + table.insert(files_to_update, {file = file, path = full_path}) + end + end + + -- Get new relative path for links + local current_dir_relative = current_dir:gsub("^" .. vim.pesc(vault_path) .. "/?", "") + local new_relative_path + if current_dir_relative == "" then + -- File is in vault root + new_relative_path = new_name + else + -- File is in subdirectory + new_relative_path = current_dir_relative .. "/" .. new_name + end + + -- Ask for confirmation + local message = "Rename '" .. relative_path .. "' to '" .. new_name .. "'" + if #files_to_update > 0 then + message = message .. " and update " .. #files_to_update .. " files with links?" + else + message = message .. "?" + end + + local confirm = vim.fn.confirm(message, "&Yes\n&No", 2) + if confirm ~= 1 then + return + end + + -- Update all linking files + for _, file_info in ipairs(files_to_update) do + local file_content = vim.fn.readfile(file_info.path) + local content_str = table.concat(file_content, "\n") + + -- Replace exact links using simple string replacement + local old_link = "[[" .. relative_path .. "]]" + local new_link = "[[" .. new_relative_path .. "]]" + content_str = content_str:gsub(vim.pesc(old_link), new_link) + + -- Replace display text links + local old_display_pattern = "(%[%[)" .. vim.pesc(relative_path) .. "(%|[^%]]*%]%])" + local new_display_replacement = "%1" .. new_relative_path .. "%2" + content_str = content_str:gsub(old_display_pattern, new_display_replacement) + + -- Write updated content + local updated_lines = vim.split(content_str, "\n") + vim.fn.writefile(updated_lines, file_info.path) + update_count = update_count + 1 + end + + -- Rename the actual file + local success = vim.fn.rename(current_path, new_file_path) + if success == 0 then + vim.cmd("edit " .. vim.fn.fnameescape(new_file_path)) + if update_count > 0 then + vim.notify("Renamed note and updated " .. update_count .. " files", vim.log.levels.INFO) + else + vim.notify("Renamed note (no links to update)", vim.log.levels.INFO) + end + else + vim.notify("Failed to rename file", vim.log.levels.ERROR) + end +end + return M \ No newline at end of file diff --git a/tests/markdown-notes/links_spec.lua b/tests/markdown-notes/links_spec.lua new file mode 100644 index 0000000..9929af1 --- /dev/null +++ b/tests/markdown-notes/links_spec.lua @@ -0,0 +1,403 @@ +local links = require("markdown-notes.links") +local config = require("markdown-notes.config") + +describe("links", function() + local temp_dir = "/tmp/markdown-notes-test" + local vault_path = temp_dir .. "/vault" + + before_each(function() + -- Clean up and create test directory + vim.fn.system("rm -rf " .. temp_dir) + vim.fn.mkdir(vault_path, "p") + + -- Setup config + config.setup({ + vault_path = vault_path + }) + + -- Mock vim.fn.confirm to always return 1 (Yes) + _G.original_confirm = vim.fn.confirm + vim.fn.confirm = function(message, choices, default) + return 1 + end + + -- Mock vim.notify to capture notifications + _G.notifications = {} + _G.original_notify = vim.notify + vim.notify = function(message, level) + table.insert(_G.notifications, {message = message, level = level}) + end + end) + + after_each(function() + -- Restore original functions + vim.fn.confirm = _G.original_confirm + vim.notify = _G.original_notify + + -- Clean up + vim.fn.system("rm -rf " .. temp_dir) + end) + + describe("rename_note", function() + it("renames a note without links", function() + -- Create a test note + local note_path = vault_path .. "/test-note.md" + vim.fn.writefile({"# Test Note", "This is a test note"}, note_path) + + -- Open the note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("renamed-note") + + -- Check that the file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/renamed-note.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check notification + assert.is_true(#_G.notifications > 0) + assert.is_not_nil(_G.notifications[#_G.notifications].message:match("Renamed note")) + end) + + it("renames a note and updates simple links", function() + -- Create notes with links + local note_path = vault_path .. "/original-note.md" + local linking_note_path = vault_path .. "/linking-note.md" + + vim.fn.writefile({"# Original Note", "Content here"}, note_path) + vim.fn.writefile({"# Linking Note", "See [[original-note]] for details"}, linking_note_path) + + -- Verify initial state + local initial_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(initial_content:find("[[original-note]]", 1, true)) + + -- Open the original note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("new-name") + + -- Check that the file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check that the link was updated + local linking_content = vim.fn.readfile(linking_note_path) + local content_str = table.concat(linking_content, "\n") + + + assert.is_not_nil(content_str:find("[[new-name]]", 1, true)) + assert.is_nil(content_str:find("[[original-note]]", 1, true)) + + -- Check notification mentions updating files + assert.is_true(#_G.notifications > 0) + assert.is_not_nil(_G.notifications[#_G.notifications].message:match("updated 1 files")) + end) + + it("renames a note and updates display text links", function() + -- Create notes with display text links + local note_path = vault_path .. "/technical-doc.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({"# Technical Documentation", "Content here"}, note_path) + vim.fn.writefile({"# Index", "Check out [[technical-doc|Technical Docs]] for info"}, linking_note_path) + + -- Open the original note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("tech-guide") + + -- Check that the file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/tech-guide.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check that the display text link was updated but display text preserved + local linking_content = vim.fn.readfile(linking_note_path) + local content_str = table.concat(linking_content, "\n") + assert.is_not_nil(content_str:find("[[tech-guide|Technical Docs]]", 1, true)) + assert.is_nil(content_str:find("[[technical-doc|Technical Docs]]", 1, true)) + end) + + it("handles multiple files with different link types", function() + -- Create the note to be renamed + local note_path = vault_path .. "/main-topic.md" + vim.fn.writefile({"# Main Topic", "Content here"}, note_path) + + -- Create multiple files with different link types + local file1_path = vault_path .. "/file1.md" + local file2_path = vault_path .. "/file2.md" + local file3_path = vault_path .. "/file3.md" + + vim.fn.writefile({"See [[main-topic]] for details"}, file1_path) + vim.fn.writefile({"Reference: [[main-topic|Main Topic Page]]"}, file2_path) + vim.fn.writefile({"Both [[main-topic]] and [[main-topic|the main topic]]"}, file3_path) + + -- Open the note to rename + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("primary-topic") + + -- Check file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/primary-topic.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check all links were updated + local file1_content = table.concat(vim.fn.readfile(file1_path), "\n") + local file2_content = table.concat(vim.fn.readfile(file2_path), "\n") + local file3_content = table.concat(vim.fn.readfile(file3_path), "\n") + + assert.is_not_nil(file1_content:find("[[primary-topic]]", 1, true)) + assert.is_not_nil(file2_content:find("[[primary-topic|Main Topic Page]]", 1, true)) + assert.is_not_nil(file3_content:find("[[primary-topic]]", 1, true)) + assert.is_not_nil(file3_content:find("[[primary-topic|the main topic]]", 1, true)) + + -- Check notification mentions updating 3 files + assert.is_true(#_G.notifications > 0) + assert.is_not_nil(_G.notifications[#_G.notifications].message:match("updated 3 files")) + end) + + it("prevents overwriting existing files", function() + -- Create original note and target note + local note_path = vault_path .. "/original.md" + local existing_path = vault_path .. "/existing.md" + + vim.fn.writefile({"# Original"}, note_path) + vim.fn.writefile({"# Existing"}, existing_path) + + -- Open original note + vim.cmd("edit " .. note_path) + + -- Try to rename to existing file name + links.rename_note("existing") + + -- Check that original file was not renamed + assert.is_true(vim.fn.filereadable(note_path) == 1) + assert.is_true(vim.fn.filereadable(existing_path) == 1) + + -- Check error notification + assert.is_true(#_G.notifications > 0) + local found_error = false + for _, notification in ipairs(_G.notifications) do + if notification.message:match("File already exists") then + found_error = true + break + end + end + assert.is_true(found_error) + end) + + it("handles notes in subdirectories", function() + -- Create subdirectory and note + local subdir = vault_path .. "/projects" + vim.fn.mkdir(subdir, "p") + local note_path = subdir .. "/project-a.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({"# Project A"}, note_path) + vim.fn.writefile({"See [[projects/project-a]] for details"}, linking_note_path) + + -- Open the note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("alpha-project") + + -- Check file was renamed in same directory + assert.is_true(vim.fn.filereadable(subdir .. "/alpha-project.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check link was updated with correct path + local linking_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(linking_content:find("[[projects/alpha-project]]", 1, true)) + assert.is_nil(linking_content:find("[[projects/project-a]]", 1, true)) + end) + + it("strips .md extension from new name", function() + -- Create a test note + local note_path = vault_path .. "/test.md" + vim.fn.writefile({"# Test"}, note_path) + + -- Open the note + vim.cmd("edit " .. note_path) + + -- Rename with .md extension + links.rename_note("new-name.md") + + -- Check that file was renamed without double extension + assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) + assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md.md") == 0) + end) + + it("handles similar note names without partial matches", function() + -- Create notes with similar names + local note_path = vault_path .. "/project.md" + local similar_note_path = vault_path .. "/project-archive.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({"# Project"}, note_path) + vim.fn.writefile({"# Project Archive"}, similar_note_path) + vim.fn.writefile({ + "# Index", + "See [[project]] for current work", + "See [[project-archive]] for old work" + }, linking_note_path) + + -- Verify initial state + local initial_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(initial_content:find("[[project]]", 1, true)) + assert.is_not_nil(initial_content:find("[[project-archive]]", 1, true)) + + -- Open and rename the "project" note + vim.cmd("edit " .. note_path) + links.rename_note("main-project") + + -- Check that files were renamed correctly + assert.is_true(vim.fn.filereadable(vault_path .. "/main-project.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + assert.is_true(vim.fn.filereadable(similar_note_path) == 1) -- Should still exist + + -- Check that links were updated correctly + local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + + -- Should find the new link + assert.is_not_nil(final_content:find("[[main-project]]", 1, true)) + + -- Should NOT find the old exact link + assert.is_nil(final_content:find("[[project]]", 1, true)) + + -- Should still have the similar link UNCHANGED + assert.is_not_nil(final_content:find("[[project-archive]]", 1, true)) + + -- Verify the similar link wasn't corrupted + assert.is_nil(final_content:find("[[main-project-archive]]", 1, true)) + + print("Final content:", final_content) + end) + + it("handles very similar note names correctly", function() + -- Test even trickier edge cases + local note_path = vault_path .. "/api.md" + local linking_note_path = vault_path .. "/docs.md" + + vim.fn.writefile({"# API"}, note_path) + vim.fn.writefile({ + "Links: [[api]], [[api-docs]], [[api-v2]], [[legacy-api]]" + }, linking_note_path) + + -- Open and rename + vim.cmd("edit " .. note_path) + links.rename_note("new-api") + + -- Check final content + local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + + -- Only the exact match should be replaced + assert.is_not_nil(final_content:find("[[new-api]]", 1, true)) + assert.is_not_nil(final_content:find("[[api-docs]]", 1, true)) + assert.is_not_nil(final_content:find("[[api-v2]]", 1, true)) + assert.is_not_nil(final_content:find("[[legacy-api]]", 1, true)) + + -- The old exact link should be gone + assert.is_nil(final_content:find("[[api]]", 1, true)) + + print("Very similar test result:", final_content) + end) + + it("handles files with spaces in names", function() + -- Create notes with spaces in filenames + local note_path = vault_path .. "/my project.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({"# My Project"}, note_path) + vim.fn.writefile({"See [[my project]] for details"}, linking_note_path) + + -- Open and rename + vim.cmd("edit " .. vim.fn.fnameescape(note_path)) + links.rename_note("new project name") + + -- Check results + assert.is_true(vim.fn.filereadable(vault_path .. "/new project name.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(final_content:find("[[new project name]]", 1, true)) + assert.is_nil(final_content:find("[[my project]]", 1, true)) + end) + + it("handles empty or whitespace-only names gracefully", function() + local note_path = vault_path .. "/test.md" + vim.fn.writefile({"# Test"}, note_path) + vim.cmd("edit " .. note_path) + + -- Clear notifications + _G.notifications = {} + + -- Test empty string + links.rename_note("") + assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist + + -- Test whitespace only + links.rename_note(" ") + assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist + + -- Should have error notifications + local found_error = false + for _, notification in ipairs(_G.notifications) do + if notification.level == vim.log.levels.ERROR then + found_error = true + break + end + end + assert.is_true(found_error) + end) + + it("handles invalid filename characters", function() + local note_path = vault_path .. "/test.md" + vim.fn.writefile({"# Test"}, note_path) + vim.cmd("edit " .. note_path) + + -- Clear notifications + _G.notifications = {} + + -- Test invalid characters + links.rename_note("test/invalid") + links.rename_note("test\\invalid") + links.rename_note("test:invalid") + + -- File should still exist since rename should fail + assert.is_true(vim.fn.filereadable(note_path) == 1) + + -- Should have error notifications + local found_error = false + for _, notification in ipairs(_G.notifications) do + if notification.level == vim.log.levels.ERROR and + notification.message:find("invalid characters") then + found_error = true + break + end + end + assert.is_true(found_error) + end) + + it("handles no current file gracefully", function() + -- Clear current buffer + vim.cmd("enew") + + -- Should handle gracefully without crashing + links.rename_note("test") + + -- Check for appropriate notification + assert.is_true(#_G.notifications > 0) + local found_warning = false + for _, notification in ipairs(_G.notifications) do + if notification.message:find("No current file") then + found_warning = true + break + end + end + assert.is_true(found_warning) + end) + end) +end) \ No newline at end of file From 898e4a5f586eae4795812ba88e6c13d513a3b9ce Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Sun, 6 Jul 2025 16:41:16 -0400 Subject: [PATCH 3/7] feat\!: change default keybinding prefix from o to n (#19) BREAKING CHANGE: All default keybindings now use n prefix instead of o for better semantic meaning as a notes plugin. Changes: - Update all default keybindings in config.lua - Update documentation in README.md and help files - Users relying on default keybindings must update their muscle memory or explicitly configure o mappings Migration: Users who prefer o can restore it by setting custom mappings in their configuration. --- README.md | 52 ++++++++++++++++----------------- doc/markdown-notes.txt | 54 +++++++++++++++++------------------ lua/markdown-notes/config.lua | 26 ++++++++--------- 3 files changed, 66 insertions(+), 66 deletions(-) diff --git a/README.md b/README.md index 013e8bd..df2a22d 100644 --- a/README.md +++ b/README.md @@ -75,19 +75,19 @@ require("markdown-notes").setup({ -- Key mappings mappings = { - daily_note_today = "od", - daily_note_yesterday = "oy", - daily_note_tomorrow = "ot", - new_note = "on", - new_note_from_template = "oc", - find_notes = "of", - search_notes = "os", - insert_link = "ol", - insert_template = "op", - search_tags = "og", - show_backlinks = "ob", + daily_note_today = "nd", + daily_note_yesterday = "ny", + daily_note_tomorrow = "nt", + new_note = "nn", + new_note_from_template = "nc", + find_notes = "nf", + search_notes = "ns", + insert_link = "nl", + insert_template = "np", + search_tags = "ng", + show_backlinks = "nb", follow_link = "gf", - rename_note = "or", + rename_note = "nr", }, }) ``` @@ -134,7 +134,7 @@ require("markdown-notes").setup_workspace("personal", { The plugin uses a simple, predictable workspace system: - **Default workspace**: Set via `default_workspace` in config, or first workspace configured becomes default -- **Manual switching**: Use `ow` or commands to switch active workspace +- **Manual switching**: Use `nw` or commands to switch active workspace - **Persistent**: All operations use the active workspace until you manually switch ### Commands @@ -206,43 +206,43 @@ notes.setup_workspace("personal", { ### Daily Notes -- `od` - Open today's daily note -- `oy` - Open yesterday's daily note -- `ot` - Open tomorrow's daily note +- `nd` - Open today's daily note +- `ny` - Open yesterday's daily note +- `nt` - Open tomorrow's daily note Daily notes are automatically created with your `Daily.md` template if it exists. ### Note Management -- `on` - Create a new note (uses default template if configured, otherwise basic frontmatter) -- `oc` - Create a new note from template (choose template interactively) -- `of` - Find and open existing notes with file preview -- `os` - Search within note contents with syntax highlighting +- `nn` - Create a new note (uses default template if configured, otherwise basic frontmatter) +- `nc` - Create a new note from template (choose template interactively) +- `nf` - Find and open existing notes with file preview +- `ns` - Search within note contents with syntax highlighting ### Links and Navigation -- `ol` - Search for a note and insert a `[[wiki-link]]` +- `nl` - Search for a note and insert a `[[wiki-link]]` - Press `Enter` to open the selected note - Press `Ctrl+L` to insert a link to the note - `gf` - Follow the link under cursor -- `ob` - Show backlinks to the current note with file preview +- `nb` - Show backlinks to the current note with file preview - Press `Enter` to open the selected note - Press `Ctrl+L` to insert a link to the note -- `or` - Rename the current note and update all references +- `nr` - Rename the current note and update all references - Prompts for new name and shows confirmation with file count - Updates all `[[wiki-links]]` and `[[link|display text]]` references - Handles files in subdirectories and prevents partial matches ### Templates -- `op` - Insert a template at cursor position with file preview +- `np` - Insert a template at cursor position with file preview - Templates support variable substitution with `{{variable}}` syntax - Configure `default_template` to automatically apply a template to new notes ### Tags -- `og` - Search for tags from frontmatter (YAML tags: [tag1, tag2]) -- `ow` - Pick workspace with fuzzy finder +- `ng` - Search for tags from frontmatter (YAML tags: [tag1, tag2]) +- `nw` - Pick workspace with fuzzy finder - Shows tag list with file counts - Select a tag to view files containing that tag with preview diff --git a/doc/markdown-notes.txt b/doc/markdown-notes.txt index 9da1284..40188ea 100644 --- a/doc/markdown-notes.txt +++ b/doc/markdown-notes.txt @@ -94,19 +94,19 @@ Default configuration: > -- Key mappings mappings = { - daily_note_today = "od", - daily_note_yesterday = "oy", - daily_note_tomorrow = "ot", - new_note = "on", - new_note_from_template = "oc", - find_notes = "of", - search_notes = "os", - insert_link = "ol", - insert_template = "op", - search_tags = "og", - show_backlinks = "ob", + daily_note_today = "nd", + daily_note_yesterday = "ny", + daily_note_tomorrow = "nt", + new_note = "nn", + new_note_from_template = "nc", + find_notes = "nf", + search_notes = "ns", + insert_link = "nl", + insert_template = "np", + search_tags = "ng", + show_backlinks = "nb", follow_link = "gf", - rename_note = "or", + rename_note = "nr", }, }) < @@ -189,7 +189,7 @@ Workspace Behavior~ The plugin uses a simple, predictable workspace system: - **Default workspace**: Set via `default_workspace` in config, or first workspace configured becomes default -- **Manual switching**: Use `ow` or commands to switch active workspace +- **Manual switching**: Use `nw` or commands to switch active workspace - **Persistent**: All operations use the active workspace until you manually switch All plugin commands use the currently active workspace configuration. @@ -235,42 +235,42 @@ Daily Notes~ *markdown-notes-daily-notes* Create and navigate daily notes with automatic templating. -- `od` - Open today's daily note -- `oy` - Open yesterday's daily note -- `ot` - Open tomorrow's daily note +- `nd` - Open today's daily note +- `ny` - Open yesterday's daily note +- `nt` - Open tomorrow's daily note Daily notes are automatically created with your `Daily.md` template if it exists. Note Management~ *markdown-notes-note-management* -- `on` - Create a new note (uses default template if configured, otherwise basic frontmatter) -- `oc` - Create a new note from template (choose template interactively) -- `of` - Find and open existing notes (with file preview and syntax highlighting) -- `os` - Search within note contents (with file preview and syntax highlighting) +- `nn` - Create a new note (uses default template if configured, otherwise basic frontmatter) +- `nc` - Create a new note from template (choose template interactively) +- `nf` - Find and open existing notes (with file preview and syntax highlighting) +- `ns` - Search within note contents (with file preview and syntax highlighting) Links and Navigation~ *markdown-notes-links-navigation* -- `ol` - Search for a note and insert a `[[wiki-link]]` (with file preview) +- `nl` - Search for a note and insert a `[[wiki-link]]` (with file preview) - Press `Enter` to open the selected note - Press `Ctrl+L` to insert a link to the note - `gf` - Follow the link under cursor (supports fuzzy matching) -- `ob` - Show backlinks to the current note (with file preview) +- `nb` - Show backlinks to the current note (with file preview) - Press `Enter` to open the selected note - Press `Ctrl+L` to insert a link to the note -- `or` - Rename the current note and update all references +- `nr` - Rename the current note and update all references - Prompts for new name and shows confirmation with file count - Updates all `[[wiki-links]]` and `[[link|display text]]` references - Handles files in subdirectories and prevents partial matches Templates~ *markdown-notes-templates* -- `op` - Insert a template at cursor position (with file preview) +- `np` - Insert a template at cursor position (with file preview) - Templates support variable substitution with `{{variable}}` syntax Tags~ *markdown-notes-tags* -- `og` - Search for tags in frontmatter (YAML format: `tags: [tag1, tag2]`) -- `ow` - Pick workspace with fuzzy finder +- `ng` - Search for tags in frontmatter (YAML format: `tags: [tag1, tag2]`) +- `nw` - Pick workspace with fuzzy finder - Shows tag list with file counts - Select a tag to view files containing that tag with preview @@ -449,7 +449,7 @@ When following links with `gf`, the plugin uses fuzzy matching: Backlinks Detection~ *markdown-notes-backlinks-detection* -The backlinks feature (`ob`) detects both: +The backlinks feature (`nb`) detects both: - Basic links: `[[current-note]]` - Links with display text: `[[current-note|custom text]]` diff --git a/lua/markdown-notes/config.lua b/lua/markdown-notes/config.lua index d7d7908..1e9e8cf 100644 --- a/lua/markdown-notes/config.lua +++ b/lua/markdown-notes/config.lua @@ -23,20 +23,20 @@ M.defaults = { -- Key mappings mappings = { - daily_note_today = "od", - daily_note_yesterday = "oy", - daily_note_tomorrow = "ot", - new_note = "on", - new_note_from_template = "oc", - find_notes = "of", - search_notes = "os", - insert_link = "ol", - insert_template = "op", - search_tags = "og", - show_backlinks = "ob", + daily_note_today = "nd", + daily_note_yesterday = "ny", + daily_note_tomorrow = "nt", + new_note = "nn", + new_note_from_template = "nc", + find_notes = "nf", + search_notes = "ns", + insert_link = "nl", + insert_template = "np", + search_tags = "ng", + show_backlinks = "nb", follow_link = "gf", - rename_note = "or", - pick_workspace = "ow", + rename_note = "nr", + pick_workspace = "nw", }, } From a6c419b443a51c96b35d2aed0df651f54f23548a Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Sun, 6 Jul 2025 17:34:54 -0400 Subject: [PATCH 4/7] docs: comprehensive README and documentation overhaul - Redesign README with modern structure, badges, and clear navigation - Add Quick Start section for immediate productivity - Reorganize content flow from basic to advanced usage - Update all default paths from ~/repos/notes to ~/notes - Add practical examples and real-world templates - Improve keybinding reference with grouped categories - Enhance troubleshooting section with common solutions - Remove Unicode/emoji characters from Vim help documentation - Convert markdown tables to proper Vim help formatting - Update LICENSE copyright to Jason Paris - Remove marksman LSP suggestion to simplify requirements - Add comprehensive workspace documentation with examples --- LICENSE | 2 +- README.md | 537 ++++++++++++++++++++---------- doc/markdown-notes.txt | 721 +++++++++++++++++++++-------------------- doc/tags | 57 ++-- 4 files changed, 760 insertions(+), 557 deletions(-) diff --git a/LICENSE b/LICENSE index 6589501..eeb0134 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2025 paris3200 +Copyright (c) 2025 Jason Paris Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md index df2a22d..5b697fc 100644 --- a/README.md +++ b/README.md @@ -1,35 +1,82 @@ -# markdown-notes.nvim +# 📝 markdown-notes.nvim -A simple, configurable markdown note-taking plugin for Neovim with support for daily notes, templates, wiki-style linking, and powerful search capabilities. +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) +[![Neovim](https://img.shields.io/badge/Neovim-0.8+-green.svg)](https://neovim.io/) -## Features +**A powerful, lightweight markdown note-taking plugin for Neovim that transforms your editor into a comprehensive knowledge management system.** -- **Daily Notes**: Quick creation and navigation of daily notes with automatic templating -- **Template-based Note Creation**: Create notes with default templates or choose from available templates -- **Templates**: Flexible template system with variable substitution (`{{date}}`, `{{time}}`, `{{title}}`, etc.) -- **Wiki-style Links**: Create and follow `[[note-name]]` links between notes -- **Note Renaming**: Rename notes and automatically update all references across your vault -- **Powerful Search**: Find notes by filename or content, search frontmatter tags with syntax highlighting -- **Backlinks**: Discover which notes reference the current note -- **Workspaces**: Support for multiple independent note vaults with manual switching -- **Configurable**: Customize paths, keybindings, and behavior +Perfect for developers, researchers, and knowledge workers who want to seamlessly integrate note-taking into their Neovim workflow. -## Requirements +## 📋 Table of Contents -- Neovim >= 0.8.0 -- [fzf-lua](https://github.com/ibhagwan/fzf-lua) for fuzzy finding -- [marksman](https://github.com/artempyanykh/marksman) LSP (optional, for enhanced link completion) +- [✨ Quick Start](#-quick-start) +- [🚀 Features](#-features) +- [đŸ“Ļ Installation](#-installation) +- [⚙ī¸ Basic Configuration](#ī¸-basic-configuration) +- [📖 Usage Guide](#-usage-guide) +- [🔧 Advanced Configuration](#-advanced-configuration) +- [📄 Template System](#-template-system) +- [🛠ī¸ Troubleshooting](#ī¸-troubleshooting) +- [🤝 Contributing](#-contributing) +- [📜 License](#-license) -## Installation +## ✨ Quick Start -### Using [lazy.nvim](https://github.com/folke/lazy.nvim) +**1. Install with your favorite plugin manager:** ```lua +-- lazy.nvim { "paris3200/markdown-notes.nvim", - dependencies = { - "ibhagwan/fzf-lua", - }, + dependencies = { "ibhagwan/fzf-lua" }, + config = true, +} +``` + +**2. Start taking notes immediately:** +- `nd` - Create today's daily note +- `nn` - Create a new note +- `nf` - Find existing notes +- `ns` - Search note contents + +**3. Create your first template** (optional): +```bash +mkdir -p ~/notes/templates +echo "# {{title}}\n\nCreated: {{date}}" > ~/notes/templates/basic.md +``` + +That's it! You're ready to start building your knowledge base. + +## 🚀 Features + +### Core Features +- **📅 Daily Notes** - Quick creation and navigation with automatic templating +- **📝 Template System** - Flexible templates with variable substitution (`{{date}}`, `{{time}}`, `{{title}}`, etc.) +- **🔗 Wiki-style Links** - Create and follow `[[note-name]]` links between notes +- **🔄 Smart Renaming** - Rename notes and automatically update all references +- **🔍 Powerful Search** - Find notes by filename or content with syntax highlighting +- **↩ī¸ Backlinks** - Discover which notes reference the current note + +### Advanced Features +- **đŸĸ Multi-Workspace Support** - Manage multiple independent note vaults +- **🏷ī¸ Tag Management** - Search and organize by frontmatter tags +- **⚡ High Performance** - Built for speed with fuzzy finding via fzf-lua +- **🎨 Highly Configurable** - Customize paths, keybindings, and behavior + +## đŸ“Ļ Installation + +### Requirements +- **Neovim >= 0.8.0** +- **[fzf-lua](https://github.com/ibhagwan/fzf-lua)** - Required for fuzzy finding + +### Plugin Managers + +#### [lazy.nvim](https://github.com/folke/lazy.nvim) (Recommended) + +```lua +{ + "paris3200/markdown-notes.nvim", + dependencies = { "ibhagwan/fzf-lua" }, config = function() require("markdown-notes").setup({ -- your configuration here @@ -38,7 +85,7 @@ A simple, configurable markdown note-taking plugin for Neovim with support for d } ``` -### Using [packer.nvim](https://github.com/wbthomason/packer.nvim) +#### [packer.nvim](https://github.com/wbthomason/packer.nvim) ```lua use { @@ -50,18 +97,147 @@ use { } ``` -## Configuration +#### [vim-plug](https://github.com/junegunn/vim-plug) -Default configuration: +```vim +Plug 'ibhagwan/fzf-lua' +Plug 'paris3200/markdown-notes.nvim' + +" In your init.lua or after/plugin/markdown-notes.lua +lua require("markdown-notes").setup() +``` + +## ⚙ī¸ Basic Configuration + +The plugin works out of the box with sensible defaults. Here's a minimal setup: ```lua require("markdown-notes").setup({ - vault_path = "~/repos/notes", - templates_path = "~/repos/notes/sys/templates", - dailies_path = "~/repos/notes/personal/dailies/2025", - weekly_path = "~/repos/notes/personal/weekly", + vault_path = "~/notes", -- Where your notes live + templates_path = "~/notes/templates", -- Where your templates live + dailies_path = "~/notes/daily", -- Where daily notes go +}) +``` + +### Key Mappings (Default) + +All keybindings use `n` as the prefix for easy discovery: + +| Keybinding | Action | Description | +|------------|--------|-------------| +| `nd` | Daily note (today) | Create/open today's daily note | +| `ny` | Daily note (yesterday) | Open yesterday's daily note | +| `nt` | Daily note (tomorrow) | Open tomorrow's daily note | +| `nn` | New note | Create a new note | +| `nc` | New note from template | Create note with template selection | +| `nf` | Find notes | Search and open existing notes | +| `ns` | Search notes | Search within note contents | +| `nl` | Insert link | Search for note and insert wiki-link | +| `np` | Insert template | Insert template at cursor | +| `ng` | Search tags | Find notes by frontmatter tags | +| `nb` | Show backlinks | Show notes linking to current note | +| `nr` | Rename note | Rename note and update all references | +| `nw` | Pick workspace | Switch between workspaces | +| `gf` | Follow link | Follow link under cursor | + +> **💡 Tip:** All keybindings can be customized in your configuration. + +## 📖 Usage Guide + +### Getting Started with Daily Notes + +Daily notes are the heart of many note-taking workflows. Start your day by creating today's note: + +``` +nd → Creates/opens today's daily note (e.g., 2025-01-15.md) +``` + +If you have a `Daily.md` template, it will be automatically applied. Otherwise, a basic note with frontmatter is created. + +### Creating and Managing Notes + +#### Basic Note Creation +``` +nn → Create a new note with your default template +nc → Choose from available templates +``` + +#### Finding and Searching +``` +nf → Fuzzy find notes by filename (with live preview) +ns → Search inside note contents (with syntax highlighting) +ng → Search by frontmatter tags +``` + +### Working with Links + +#### Creating Links Between Notes +``` +nl → Search for a note and insert [[wiki-link]] + Press Ctrl+L to just insert the link + Press Enter to open the note +``` + +#### Following and Managing Links +``` +gf → Follow the link under cursor +nb → Show all notes that link to current note (backlinks) +nr → Rename current note and update all references +``` + +### Using Templates + +Templates make your notes consistent and save time: + +``` +np → Insert template at cursor position +``` + +**Example template** (`~/notes/templates/meeting.md`): +```markdown +--- +title: {{title}} +date: {{date}} +tags: [meetings] +--- + +# {{title}} + +**Date:** {{datetime}} +**Attendees:** + +## Agenda + +## Notes + +## Action Items +- [ ] +``` + +### Command Reference + +| Command | Description | +|---------|-------------| +| `:MarkdownNotesRename [name]` | Rename current note and update references | +| `:MarkdownNotesWorkspaceStatus` | Show current workspace | +| `:MarkdownNotesWorkspacePick` | Switch workspace with fuzzy finder | +| `:MarkdownNotesWorkspaceSwitch ` | Switch to specific workspace | + +## 🔧 Advanced Configuration + +### Custom Configuration Options + +```lua +require("markdown-notes").setup({ + -- Core paths + vault_path = "~/notes", + templates_path = "~/notes/templates", + dailies_path = "~/notes/daily", + weekly_path = "~/notes/weekly", notes_subdir = "notes", - default_template = nil, -- Optional: default template for new notes (e.g., "note") + + -- Template settings + default_template = "basic", -- Auto-apply this template to new notes -- Custom template variables template_vars = { @@ -71,9 +247,12 @@ require("markdown-notes").setup({ title = function() return vim.fn.expand("%:t:r") end, yesterday = function() return os.date("%Y-%m-%d", os.time() - 86400) end, tomorrow = function() return os.date("%Y-%m-%d", os.time() + 86400) end, + -- Add your own custom variables + author = function() return "Your Name" end, + project = function() return vim.fn.getcwd():match("([^/]+)$") end, }, - -- Key mappings + -- Customize keybindings mappings = { daily_note_today = "nd", daily_note_yesterday = "ny", @@ -92,212 +271,220 @@ require("markdown-notes").setup({ }) ``` -## Workspaces +### Multi-Workspace Configuration -Workspaces allow you to manage multiple independent note vaults simultaneously. Each workspace has its own configuration for paths, templates, and settings. You can set a default workspace and manually switch between them as needed. +Workspaces allow you to manage multiple independent note vaults simultaneously. Perfect for separating work notes, personal notes, and project-specific documentation. -### Workspace Setup +#### Setting Up Workspaces ```lua --- Basic plugin setup with default workspace +-- Base configuration (becomes your default workspace) require("markdown-notes").setup({ vault_path = "~/notes", templates_path = "~/notes/templates", - default_workspace = "personal", -- Optional: specify which workspace to use by default + default_workspace = "personal", -- Optional: specify default }) --- Set up work workspace +-- Work workspace require("markdown-notes").setup_workspace("work", { vault_path = "~/work-notes", templates_path = "~/work-notes/templates", - dailies_path = "~/work-notes/dailies", - notes_subdir = "projects", + dailies_path = "~/work-notes/standups", default_template = "work-note", template_vars = { - -- Custom variables for work notes project = function() return "Current Project" end, + sprint = function() return "Sprint-" .. os.date("%U") end, }, }) --- Set up personal workspace -require("markdown-notes").setup_workspace("personal", { - vault_path = "~/personal-notes", - templates_path = "~/personal-notes/templates", - dailies_path = "~/personal-notes/journal", - notes_subdir = "thoughts", - default_template = "personal-note", +-- Research workspace +require("markdown-notes").setup_workspace("research", { + vault_path = "~/research/papers", + templates_path = "~/research/templates", + dailies_path = "~/research/lab-notes", + default_template = "research-paper", }) ``` -### Workspace Behavior +#### Workspace Workflow -The plugin uses a simple, predictable workspace system: +- **Switch workspaces**: Use `nw` to pick from available workspaces +- **Persistent context**: All commands use the active workspace until you switch +- **Independent settings**: Each workspace has its own paths, templates, and variables -- **Default workspace**: Set via `default_workspace` in config, or first workspace configured becomes default -- **Manual switching**: Use `nw` or commands to switch active workspace -- **Persistent**: All operations use the active workspace until you manually switch +### Directory Structure Example -### Commands +``` +~/notes/ # Main vault +├── templates/ # Your templates +│ ├── Daily.md # Auto-applied to daily notes +│ ├── meeting.md # Meeting template +│ └── project.md # Project template +├── daily/ # Daily notes +│ ├── 2025-01-15.md +│ └── 2025-01-16.md +└── notes/ # Regular notes + ├── project-ideas.md + └── learning-resources.md +``` -**Note Management:** -- `:MarkdownNotesRename [name]` - Rename current note and update all references (prompts if no name provided) +## 📄 Template System -**Workspace Management:** -- `:MarkdownNotesWorkspaceStatus` - Show current workspace for the buffer -- `:MarkdownNotesWorkspacePick` - Pick workspace with fuzzy finder -- `:MarkdownNotesWorkspaceSwitch ` - Switch to a workspace directory +Templates are markdown files with special `{{variable}}` syntax that gets substituted when creating notes. -### Multi-Vault Workflow +### Built-in Template Variables -With workspaces, you can: +| Variable | Output | Example | +|----------|--------|---------| +| `{{date}}` | Current date | `2025-01-15` | +| `{{time}}` | Current time | `14:30` | +| `{{datetime}}` | Date and time | `2025-01-15 14:30` | +| `{{title}}` | File name without extension | `meeting-notes` | +| `{{yesterday}}` | Yesterday's date | `2025-01-14` | +| `{{tomorrow}}` | Tomorrow's date | `2025-01-16` | -1. **Work on multiple projects simultaneously**: Have work notes open in one split and personal notes in another -2. **Context-specific templates**: Use different templates for work vs personal notes -3. **Separate organization**: Each workspace maintains its own directory structure and settings -4. **Seamless switching**: All plugin commands automatically use the correct workspace configuration +### Creating Custom Variables -### Example Multi-Workspace Setup +Add custom variables in your configuration: ```lua --- ~/.config/nvim/lua/config/notes.lua -local notes = require("markdown-notes") - --- Base configuration -notes.setup({ - vault_path = "~/notes", - templates_path = "~/notes/templates", -}) - --- Work workspace -notes.setup_workspace("work", { - vault_path = "~/work/knowledge-base", - templates_path = "~/work/knowledge-base/templates", - dailies_path = "~/work/knowledge-base/daily-standups", - notes_subdir = "projects", - default_template = "work-note", +require("markdown-notes").setup({ template_vars = { - sprint = function() return "Sprint-" .. os.date("%U") end, - standup_date = function() return os.date("%A, %B %d") end, + author = function() return "Your Name" end, + project = function() return vim.fn.getcwd():match("([^/]+)$") end, + week = function() return os.date("Week %U") end, + uuid = function() return vim.fn.system("uuidgen"):gsub("\n", "") end, }, }) +``` --- Research workspace -notes.setup_workspace("research", { - vault_path = "~/research/papers", - templates_path = "~/research/templates", - dailies_path = "~/research/lab-notes", - notes_subdir = "literature", - default_template = "research-paper", - template_vars = { - citation = function() return "[@author" .. os.date("%Y") .. "]" end, - }, -}) +### Example Templates --- Personal workspace -notes.setup_workspace("personal", { - vault_path = "~/personal/journal", - templates_path = "~/personal/templates", - dailies_path = "~/personal/daily", - default_template = "journal-entry", -}) -``` +**Daily Note Template** (`templates/Daily.md`): +```markdown +--- +title: Daily Note - {{date}} +date: {{date}} +tags: [daily] +--- -## Usage +# {{date}} - Daily Notes -### Daily Notes +## đŸŽ¯ Today's Goals +- [ ] -- `nd` - Open today's daily note -- `ny` - Open yesterday's daily note -- `nt` - Open tomorrow's daily note +## 📝 Notes -Daily notes are automatically created with your `Daily.md` template if it exists. +## 🔄 Tomorrow's Prep +- [ ] +``` -### Note Management +**Meeting Template** (`templates/meeting.md`): +```markdown +--- +title: {{title}} +date: {{date}} +tags: [meeting] +attendees: [] +--- -- `nn` - Create a new note (uses default template if configured, otherwise basic frontmatter) -- `nc` - Create a new note from template (choose template interactively) -- `nf` - Find and open existing notes with file preview -- `ns` - Search within note contents with syntax highlighting +# {{title}} -### Links and Navigation +**Date:** {{datetime}} +**Attendees:** -- `nl` - Search for a note and insert a `[[wiki-link]]` - - Press `Enter` to open the selected note - - Press `Ctrl+L` to insert a link to the note -- `gf` - Follow the link under cursor -- `nb` - Show backlinks to the current note with file preview - - Press `Enter` to open the selected note - - Press `Ctrl+L` to insert a link to the note -- `nr` - Rename the current note and update all references - - Prompts for new name and shows confirmation with file count - - Updates all `[[wiki-links]]` and `[[link|display text]]` references - - Handles files in subdirectories and prevents partial matches +## 📋 Agenda -### Templates +## 📝 Discussion Notes -- `np` - Insert a template at cursor position with file preview -- Templates support variable substitution with `{{variable}}` syntax -- Configure `default_template` to automatically apply a template to new notes +## ✅ Action Items +- [ ] -### Tags +## 🔗 Links +``` -- `ng` - Search for tags from frontmatter (YAML tags: [tag1, tag2]) -- `nw` - Pick workspace with fuzzy finder - - Shows tag list with file counts - - Select a tag to view files containing that tag with preview +## 🛠ī¸ Troubleshooting -## Template Variables +### Common Issues -Available template variables: +#### "fzf-lua not found" Error +**Solution:** Install fzf-lua dependency: +```lua +-- lazy.nvim +dependencies = { "ibhagwan/fzf-lua" } -- `{{date}}` - Current date (YYYY-MM-DD) -- `{{time}}` - Current time (HH:MM) -- `{{datetime}}` - Current date and time -- `{{title}}` - Current file name without extension -- `{{note_title}}` - User-provided title when creating notes (same as `{{title}}` for note creation) -- `{{yesterday}}` - Yesterday's date -- `{{tomorrow}}` - Tomorrow's date +-- packer.nvim +requires = { "ibhagwan/fzf-lua" } +``` -Example template usage: -```markdown ---- -title: {{title}} -date: {{date}} -tags: [] ---- +#### Templates Not Working +**Checklist:** +1. Verify `templates_path` exists and contains `.md` files +2. Check template syntax uses `{{variable}}` (not `{variable}`) +3. Ensure template file permissions are readable -# {{title}} +#### Links Not Following (`gf` not working) +**Solution:** Ensure you're using the correct link format: +- ✅ `[[note-name]]` or `[[note-name.md]]` +- ❌ `[note-name](note-name.md)` (standard markdown links) -Created on {{datetime}} -``` +#### Performance Issues with Large Vaults +**Solutions:** +- Use `.gitignore` to exclude non-note files from searches +- Consider splitting large vaults into multiple workspaces +- Ensure fzf-lua is properly configured -## Directory Structure +### Debug Information +Check your configuration: +```lua +:lua print(vim.inspect(require("markdown-notes").config)) ``` -~/repos/notes/ -├── sys/ -│ └── templates/ -│ ├── Daily.md -│ ├── Meeting.md -│ └── Project.md -├── personal/ -│ └── dailies/ -│ └── 2025/ -│ ├── 2025-01-01.md -│ └── 2025-01-02.md -└── notes/ - ├── project-ideas.md - └── learning-resources.md + +Check current workspace: +``` +:MarkdownNotesWorkspaceStatus +``` + +## 🤝 Contributing + +We welcome contributions! Here's how to get started: + +1. **Fork** the repository +2. **Create** a feature branch (`git checkout -b feature/amazing-feature`) +3. **Make** your changes +4. **Test** your changes (run tests if applicable) +5. **Commit** your changes (`git commit -m 'feat: add amazing feature'`) +6. **Push** to the branch (`git push origin feature/amazing-feature`) +7. **Open** a Pull Request + +### Development Setup + +```bash +# Clone your fork +git clone https://github.com/yourusername/markdown-notes.nvim.git +cd markdown-notes.nvim + +# Run tests (requires plenary.nvim) +nvim --headless -u tests/minimal_init.vim -c "lua require('plenary.test_harness').test_directory('tests')" ``` -## Contributing +### Reporting Issues -1. Fork the repository -2. Create a feature branch -3. Make your changes -4. Add tests if applicable -5. Submit a pull request +- Use GitHub Issues for bug reports and feature requests +- Include your Neovim version and plugin configuration +- Provide steps to reproduce the issue -## License +## 📜 License MIT License - see [LICENSE](LICENSE) file for details. + +--- + +
+ +**Happy note-taking! 📝** + +If you find this plugin useful, consider ⭐ starring the repository! + +
diff --git a/doc/markdown-notes.txt b/doc/markdown-notes.txt index 40188ea..3e7a9a3 100644 --- a/doc/markdown-notes.txt +++ b/doc/markdown-notes.txt @@ -4,54 +4,85 @@ CONTENTS *markdown-notes-contents* 1. Introduction |markdown-notes-introduction| -2. Requirements |markdown-notes-requirements| -3. Installation |markdown-notes-installation| -4. Configuration |markdown-notes-configuration| -5. Workspaces |markdown-notes-workspaces| -6. Usage |markdown-notes-usage| -7. Commands |markdown-notes-commands| -8. Note Naming |markdown-notes-note-naming| -9. Template Variables |markdown-notes-template-vars| -10. Directory Structure |markdown-notes-directory| -11. Link Formats |markdown-notes-link-formats| +2. Quick Start |markdown-notes-quick-start| +3. Requirements |markdown-notes-requirements| +4. Installation |markdown-notes-installation| +5. Basic Configuration |markdown-notes-basic-config| +6. Usage Guide |markdown-notes-usage-guide| +7. Key Mappings |markdown-notes-key-mappings| +8. Advanced Configuration |markdown-notes-advanced-config| +9. Workspaces |markdown-notes-workspaces| +10. Template System |markdown-notes-template-system| +11. Commands |markdown-notes-commands| 12. Troubleshooting |markdown-notes-troubleshooting| -13. API |markdown-notes-api| +13. API Reference |markdown-notes-api| ============================================================================== INTRODUCTION *markdown-notes-introduction* -markdown-notes.nvim is a simple, configurable markdown note-taking plugin for -Neovim with support for daily notes, templates, wiki-style linking, and -powerful search capabilities. - -Features: -- Daily Notes: Quick creation and navigation of daily notes with automatic - templating -- Templates: Flexible template system with variable substitution -- Wiki-style Links: Create and follow `[[note-name]]` links between notes -- Note Renaming: Rename notes and automatically update all references -- Powerful Search: Find notes by filename or content, search tags -- Backlinks: Discover which notes reference the current note -- Workspaces: Support for multiple independent note vaults with manual switching -- Configurable: Customize paths, keybindings, and behavior +markdown-notes.nvim is a powerful, lightweight markdown note-taking plugin +for Neovim that transforms your editor into a comprehensive knowledge +management system. + +Perfect for developers, researchers, and knowledge workers who want to +seamlessly integrate note-taking into their Neovim workflow. + +FEATURES: + +Core Features~ +- Daily Notes - Quick creation and navigation with automatic templating +- Template System - Flexible templates with variable substitution +- Wiki-style Links - Create and follow [[note-name]] links between notes +- Smart Renaming - Rename notes and automatically update all references +- Powerful Search - Find notes by filename or content with syntax highlighting +- Backlinks - Discover which notes reference the current note + +Advanced Features~ +- Multi-Workspace Support - Manage multiple independent note vaults +- Tag Management - Search and organize by frontmatter tags +- High Performance - Built for speed with fuzzy finding via fzf-lua +- Highly Configurable - Customize paths, keybindings, and behavior + +============================================================================== +QUICK START *markdown-notes-quick-start* + +1. Install with your plugin manager: > + -- lazy.nvim + { + "paris3200/markdown-notes.nvim", + dependencies = { "ibhagwan/fzf-lua" }, + config = true, + } +< + +2. Start taking notes immediately: + - `nd` - Create today's daily note + - `nn` - Create a new note + - `nf` - Find existing notes + - `ns` - Search note contents + +3. Create your first template (optional): > + $ mkdir -p ~/notes/templates + $ echo "# {{title}}\n\nCreated: {{date}}" > ~/notes/templates/basic.md +< + +That's it! You're ready to start building your knowledge base. ============================================================================== REQUIREMENTS *markdown-notes-requirements* - Neovim >= 0.8.0 -- fzf-lua (https://github.com/ibhagwan/fzf-lua) for fuzzy finding -- marksman LSP (optional, for enhanced link completion) - (https://github.com/artempyanykh/marksman) +- fzf-lua (https://github.com/ibhagwan/fzf-lua) - Required for fuzzy finding ============================================================================== INSTALLATION *markdown-notes-installation* -Using lazy.nvim: > +Plugin Managers~ + +lazy.nvim (Recommended): > { "paris3200/markdown-notes.nvim", - dependencies = { - "ibhagwan/fzf-lua", - }, + dependencies = { "ibhagwan/fzf-lua" }, config = function() require("markdown-notes").setup({ -- your configuration here @@ -60,7 +91,7 @@ Using lazy.nvim: > } < -Using packer.nvim: > +packer.nvim: > use { "paris3200/markdown-notes.nvim", requires = { "ibhagwan/fzf-lua" }, @@ -70,17 +101,139 @@ Using packer.nvim: > } < +vim-plug: > + Plug 'ibhagwan/fzf-lua' + Plug 'paris3200/markdown-notes.nvim' + + " In your init.lua or after/plugin/markdown-notes.lua + lua require("markdown-notes").setup() +< + ============================================================================== -CONFIGURATION *markdown-notes-configuration* +BASIC CONFIGURATION *markdown-notes-basic-config* -Default configuration: > +The plugin works out of the box with sensible defaults. Here's a minimal +setup: > require("markdown-notes").setup({ - vault_path = "~/repos/notes", - templates_path = "~/repos/notes/sys/templates", - dailies_path = "~/repos/notes/personal/dailies/2025", - weekly_path = "~/repos/notes/personal/weekly", + vault_path = "~/notes", -- Where your notes live + templates_path = "~/notes/templates", -- Where your templates live + dailies_path = "~/notes/daily", -- Where daily notes go + }) +< + +============================================================================== +USAGE GUIDE *markdown-notes-usage-guide* + +Getting Started with Daily Notes~ + *markdown-notes-usage-daily-notes* +Daily notes are the heart of many note-taking workflows. Start your day by +creating today's note: > + nd → Creates/opens today's daily note (e.g., 2025-01-15.md) +< + +If you have a `Daily.md` template, it will be automatically applied. +Otherwise, a basic note with frontmatter is created. + +Creating and Managing Notes~ + *markdown-notes-usage-note-management* +Basic Note Creation: > + nn → Create a new note with your default template + nc → Choose from available templates +< + +Finding and Searching: > + nf → Fuzzy find notes by filename (with live preview) + ns → Search inside note contents (with syntax highlighting) + ng → Search by frontmatter tags +< + +Working with Links~ + *markdown-notes-usage-links* +Creating Links Between Notes: > + nl → Search for a note and insert [[wiki-link]] + Press Ctrl+L to just insert the link + Press Enter to open the note +< + +Following and Managing Links: > + gf → Follow the link under cursor + nb → Show all notes that link to current note (backlinks) + nr → Rename current note and update all references +< + +Using Templates~ + *markdown-notes-usage-templates* +Templates make your notes consistent and save time: > + np → Insert template at cursor position +< + +Example template (~/notes/templates/meeting.md): > + --- + title: {{title}} + date: {{date}} + tags: [meetings] + --- + + # {{title}} + + **Date:** {{datetime}} + **Attendees:** + + ## Agenda + + ## Notes + + ## Action Items + - [ ] +< + +============================================================================== +KEY MAPPINGS *markdown-notes-key-mappings* + +All keybindings use `n` as the prefix for easy discovery: + +Daily Notes~ +`nd` Create/open today's daily note +`ny` Open yesterday's daily note +`nt` Open tomorrow's daily note + +Note Management~ +`nn` Create a new note +`nc` Create note with template selection +`nf` Search and open existing notes +`ns` Search within note contents + +Links and Navigation~ +`nl` Search for note and insert wiki-link +`nb` Show notes linking to current note +`nr` Rename note and update all references +`gf` Follow link under cursor + +Templates and Tags~ +`np` Insert template at cursor +`ng` Find notes by frontmatter tags + +Workspaces~ +`nw` Switch between workspaces + +Note: All keybindings can be customized in your configuration. + +============================================================================== +ADVANCED CONFIGURATION *markdown-notes-advanced-config* + +Custom Configuration Options~ + *markdown-notes-advanced-config-opts* +> + require("markdown-notes").setup({ + -- Core paths + vault_path = "~/notes", + templates_path = "~/notes/templates", + dailies_path = "~/notes/daily", + weekly_path = "~/notes/weekly", notes_subdir = "notes", - default_template = nil, -- Optional: default template for new notes (e.g., "note") + + -- Template settings + default_template = "basic", -- Auto-apply this template to new notes -- Custom template variables template_vars = { @@ -90,9 +243,12 @@ Default configuration: > title = function() return vim.fn.expand("%:t:r") end, yesterday = function() return os.date("%Y-%m-%d", os.time() - 86400) end, tomorrow = function() return os.date("%Y-%m-%d", os.time() + 86400) end, + -- Add your own custom variables + author = function() return "Your Name" end, + project = function() return vim.fn.getcwd():match("([^/]+)$") end, }, - -- Key mappings + -- Customize keybindings mappings = { daily_note_today = "nd", daily_note_yesterday = "ny", @@ -111,102 +267,68 @@ Default configuration: > }) < - *markdown-notes-vault-path* -vault_path~ - Path to your notes vault. Default: "~/repos/notes" - - *markdown-notes-templates-path* -templates_path~ - Path to your templates directory. Default: "~/repos/notes/sys/templates" - - *markdown-notes-dailies-path* -dailies_path~ - Path to your daily notes directory. Default: "~/repos/notes/personal/dailies/2025" - - *markdown-notes-weekly-path* -weekly_path~ - Path to your weekly notes directory. Default: "~/repos/notes/personal/weekly" - - *markdown-notes-notes-subdir* -notes_subdir~ - Subdirectory within vault_path for general notes. Default: "notes" - - *markdown-notes-default-template* -default_template~ - Default template to use for new notes created with `new_note`. If set to - a template name (without .md extension), that template will be applied - automatically. If nil, basic frontmatter is used. Default: nil - - *markdown-notes-template-vars-config* -template_vars~ - Table of template variables (see |markdown-notes-template-vars|). - - *markdown-notes-mappings* -mappings~ - Table of key mappings (see |markdown-notes-commands|). +Directory Structure Example~ + *markdown-notes-advanced-directory-structure* +> + ~/notes/ # Main vault + ├── templates/ # Your templates + │ ├── Daily.md # Auto-applied to daily notes + │ ├── meeting.md # Meeting template + │ └── project.md # Project template + ├── daily/ # Daily notes + │ ├── 2025-01-15.md + │ └── 2025-01-16.md + └── notes/ # Regular notes + ├── project-ideas.md + └── learning-resources.md +< ============================================================================== WORKSPACES *markdown-notes-workspaces* -Workspaces allow you to manage multiple independent note vaults simultaneously. -Each workspace has its own configuration for paths, templates, and settings. -You can set a default workspace and manually switch between them as needed. +Workspaces allow you to manage multiple independent note vaults simultaneously. +Perfect for separating work notes, personal notes, and project-specific +documentation. -Workspace Setup~ +Setting Up Workspaces~ *markdown-notes-workspace-setup* -Basic workspace configuration: > - -- Basic plugin setup +> + -- Base configuration (becomes your default workspace) require("markdown-notes").setup({ - -- Default configuration (fallback when no workspace is detected) - vault_path = "~/default-notes", - templates_path = "~/default-notes/templates", + vault_path = "~/notes", + templates_path = "~/notes/templates", + default_workspace = "personal", -- Optional: specify default }) - - -- Set up work workspace + + -- Work workspace require("markdown-notes").setup_workspace("work", { vault_path = "~/work-notes", templates_path = "~/work-notes/templates", - dailies_path = "~/work-notes/dailies", - notes_subdir = "projects", + dailies_path = "~/work-notes/standups", default_template = "work-note", template_vars = { project = function() return "Current Project" end, + sprint = function() return "Sprint-" .. os.date("%U") end, }, }) - - -- Set up personal workspace - require("markdown-notes").setup_workspace("personal", { - vault_path = "~/personal-notes", - templates_path = "~/personal-notes/templates", - dailies_path = "~/personal-notes/journal", - notes_subdir = "thoughts", - default_template = "personal-note", + + -- Research workspace + require("markdown-notes").setup_workspace("research", { + vault_path = "~/research/papers", + templates_path = "~/research/templates", + dailies_path = "~/research/lab-notes", + default_template = "research-paper", }) < -Workspace Behavior~ - *markdown-notes-workspace-behavior* -The plugin uses a simple, predictable workspace system: - -- **Default workspace**: Set via `default_workspace` in config, or first workspace configured becomes default -- **Manual switching**: Use `nw` or commands to switch active workspace -- **Persistent**: All operations use the active workspace until you manually switch - -All plugin commands use the currently active workspace configuration. - -Commands~ - *markdown-notes-ex-commands* - -Note Management Commands~ - -:MarkdownNotesRename [{name}] *:MarkdownNotesRename* - Rename current note and update all references. If {name} is not provided, - prompts for the new name. Shows confirmation dialog with file count. - -Workspace Management Commands~ - *markdown-notes-workspace-commands* -The following commands are available for workspace management: +Workspace Workflow~ + *markdown-notes-workspace-workflow* +- Switch workspaces: Use `nw` to pick from available workspaces +- Persistent context: All commands use the active workspace until you switch +- Independent settings: Each workspace has its own paths, templates, and variables +Workspace Commands~ + *markdown-notes-workspace-commands* :MarkdownNotesWorkspaceStatus *:MarkdownNotesWorkspaceStatus* Show current workspace for the buffer @@ -214,318 +336,209 @@ The following commands are available for workspace management: Pick workspace with fuzzy finder :MarkdownNotesWorkspaceSwitch {name} *:MarkdownNotesWorkspaceSwitch* - Switch to a workspace directory. Tab completion available. + Switch to specific workspace -Multi-Vault Workflow~ - *markdown-notes-multi-vault-workflow* -With workspaces, you can: +============================================================================== +TEMPLATE SYSTEM *markdown-notes-template-system* + +Templates are markdown files with special `{{variable}}` syntax that gets +substituted when creating notes. + +Built-in Template Variables~ + *markdown-notes-template-built-in-vars* +`{{date}}` Current date (2025-01-15) +`{{time}}` Current time (14:30) +`{{datetime}}` Date and time (2025-01-15 14:30) +`{{title}}` File name without extension (meeting-notes) +`{{yesterday}}` Yesterday's date (2025-01-14) +`{{tomorrow}}` Tomorrow's date (2025-01-16) + +Creating Custom Variables~ + *markdown-notes-template-custom-vars* +Add custom variables in your configuration: > + require("markdown-notes").setup({ + template_vars = { + author = function() return "Your Name" end, + project = function() return vim.fn.getcwd():match("([^/]+)$") end, + week = function() return os.date("Week %U") end, + uuid = function() return vim.fn.system("uuidgen"):gsub("\n", "") end, + }, + }) +< -1. Work on multiple projects simultaneously: Have work notes open in one split - and personal notes in another -2. Context-specific templates: Use different templates for work vs personal notes -3. Separate organization: Each workspace maintains its own directory structure - and settings -4. Consistent behavior: All plugin commands use the active workspace - configuration +Example Templates~ + *markdown-notes-template-examples* +Daily Note Template (templates/Daily.md): > + --- + title: Daily Note - {{date}} + date: {{date}} + tags: [daily] + --- -============================================================================== -USAGE *markdown-notes-usage* + # {{date}} - Daily Notes -Daily Notes~ - *markdown-notes-daily-notes* -Create and navigate daily notes with automatic templating. + ## Today's Goals + - [ ] -- `nd` - Open today's daily note -- `ny` - Open yesterday's daily note -- `nt` - Open tomorrow's daily note + ## Notes -Daily notes are automatically created with your `Daily.md` template if it exists. + ## Tomorrow's Prep + - [ ] +< -Note Management~ - *markdown-notes-note-management* -- `nn` - Create a new note (uses default template if configured, otherwise basic frontmatter) -- `nc` - Create a new note from template (choose template interactively) -- `nf` - Find and open existing notes (with file preview and syntax highlighting) -- `ns` - Search within note contents (with file preview and syntax highlighting) +Meeting Template (templates/meeting.md): > + --- + title: {{title}} + date: {{date}} + tags: [meeting] + attendees: [] + --- -Links and Navigation~ - *markdown-notes-links-navigation* -- `nl` - Search for a note and insert a `[[wiki-link]]` (with file preview) - - Press `Enter` to open the selected note - - Press `Ctrl+L` to insert a link to the note -- `gf` - Follow the link under cursor (supports fuzzy matching) -- `nb` - Show backlinks to the current note (with file preview) - - Press `Enter` to open the selected note - - Press `Ctrl+L` to insert a link to the note -- `nr` - Rename the current note and update all references - - Prompts for new name and shows confirmation with file count - - Updates all `[[wiki-links]]` and `[[link|display text]]` references - - Handles files in subdirectories and prevents partial matches - -Templates~ - *markdown-notes-templates* -- `np` - Insert a template at cursor position (with file preview) -- Templates support variable substitution with `{{variable}}` syntax - -Tags~ - *markdown-notes-tags* -- `ng` - Search for tags in frontmatter (YAML format: `tags: [tag1, tag2]`) -- `nw` - Pick workspace with fuzzy finder - - Shows tag list with file counts - - Select a tag to view files containing that tag with preview + # {{title}} + + **Date:** {{datetime}} + **Attendees:** + + ## Agenda + + ## Discussion Notes + + ## Action Items + - [ ] + + ## Links +< ============================================================================== COMMANDS *markdown-notes-commands* +Ex Commands~ + *markdown-notes-ex-commands* +:MarkdownNotesRename [{name}] *:MarkdownNotesRename* + Rename current note and update all references. If {name} is not provided, + prompts for the new name. Shows confirmation dialog with file count. + +Function API~ + *markdown-notes-function-commands* The plugin provides the following functions that can be called directly: - *markdown-notes.create_new_note* -require("markdown-notes.notes").create_new_note() +require("markdown-notes.notes").create_new_note() *markdown-notes.create_new_note* Create a new note. Uses default template if configured, otherwise creates basic frontmatter. Prompts for optional title. - *markdown-notes.create_from_template* -require("markdown-notes.notes").create_from_template() +require("markdown-notes.notes").create_from_template() *markdown-notes.create_from_template* Create a new note from template. Prompts for title, then allows interactive template selection with file preview. - *markdown-notes.find_notes* -require("markdown-notes.notes").find_notes() +require("markdown-notes.notes").find_notes() *markdown-notes.find_notes* Find and open existing notes using fuzzy finder. - *markdown-notes.search_notes* -require("markdown-notes.notes").search_notes() +require("markdown-notes.notes").search_notes() *markdown-notes.search_notes* Search within note contents using fuzzy finder. - *markdown-notes.search_tags* -require("markdown-notes.notes").search_tags() +require("markdown-notes.notes").search_tags() *markdown-notes.search_tags* Search for tags within notes. - *markdown-notes.open_daily_note* -require("markdown-notes.daily").open_daily_note(offset) +require("markdown-notes.daily").open_daily_note(offset) *markdown-notes.open_daily_note* Open daily note. `offset` is number of days from today (0 = today, -1 = yesterday, 1 = tomorrow). - *markdown-notes.search_and_link* -require("markdown-notes.links").search_and_link() +require("markdown-notes.links").search_and_link() *markdown-notes.search_and_link* Search for a note and insert a wiki-style link. - *markdown-notes.follow_link* -require("markdown-notes.links").follow_link() +require("markdown-notes.links").follow_link() *markdown-notes.follow_link* Follow the wiki-style link under cursor. - *markdown-notes.show_backlinks* -require("markdown-notes.links").show_backlinks() +require("markdown-notes.links").show_backlinks() *markdown-notes.show_backlinks* Show backlinks to the current note. - *markdown-notes.rename_note* -require("markdown-notes.links").rename_note(new_name) +require("markdown-notes.links").rename_note(new_name) *markdown-notes.rename_note* Rename the current note and automatically update all wiki-style link references across the vault. Supports both `[[note]]` and `[[note|display]]` formats. Shows confirmation dialog with file count before proceeding. - Handles files in subdirectories and prevents partial matches. - *markdown-notes.pick_template* -require("markdown-notes.templates").pick_template() +require("markdown-notes.templates").pick_template() *markdown-notes.pick_template* Pick and insert a template at cursor position. - *markdown-notes.insert_template* -require("markdown-notes.templates").insert_template(template_name, custom_vars) +require("markdown-notes.templates").insert_template(template_name, custom_vars) *markdown-notes.insert_template* Insert a specific template with optional custom variables. - *markdown-notes.apply_template_to_file* -require("markdown-notes.templates").apply_template_to_file(template_name, custom_vars) - Replace entire buffer content with specified template. Used by - create_from_template(). Returns true on success, false on failure. - ============================================================================== -NOTE NAMING *markdown-notes-note-naming* - -The plugin uses a timestamp-based naming convention for notes to ensure unique -filenames and chronological organization. - -Filename Format~ - *markdown-notes-filename-format* -When creating a new note, the filename is generated as follows: - -- If no title is provided: `{timestamp}.md` -- If a title is provided: `{timestamp}-{sanitized-title}.md` - -Where: -- `{timestamp}` is the Unix timestamp (seconds since epoch) -- `{sanitized-title}` is the title with spaces replaced by hyphens, - non-alphanumeric characters removed, and converted to lowercase - -Examples: -- No title: `1735948800.md` -- Title "My Project Ideas": `1735948800-my-project-ideas.md` -- Title "Meeting Notes #1": `1735948800-meeting-notes-1.md` - -Benefits~ - *markdown-notes-naming-benefits* -- Unique filenames prevent conflicts -- Chronological ordering when sorted by filename -- Human-readable titles when provided -- Consistent naming across all notes - -Daily Notes~ - *markdown-notes-daily-note-naming* -Daily notes use a different naming convention based on dates: -- Format: `YYYY-MM-DD.md` -- Example: `2025-01-03.md` - -This provides a clear, date-based organization for daily notes separate from -general notes. - -============================================================================== -TEMPLATE VARIABLES *markdown-notes-template-vars* +TROUBLESHOOTING *markdown-notes-troubleshooting* -Available template variables for use in templates with `{{variable}}` syntax: +Common Issues~ + *markdown-notes-common-issues* -`{{date}}` Current date (YYYY-MM-DD) -`{{time}}` Current time (HH:MM) -`{{datetime}}` Current date and time -`{{title}}` Current file name without extension -`{{note_title}}` User-provided title when creating notes (same as `{{title}}` for note creation) -`{{yesterday}}` Yesterday's date -`{{tomorrow}}` Tomorrow's date +"fzf-lua not found" Error~ +Solution: Install fzf-lua dependency: > + -- lazy.nvim + dependencies = { "ibhagwan/fzf-lua" } -Example template: > - --- - title: {{title}} - date: {{date}} - tags: [] - --- - - # {{title}} - - Created on {{datetime}} + -- packer.nvim + requires = { "ibhagwan/fzf-lua" } < -You can define custom template variables in your configuration: > - template_vars = { - author = function() return "Your Name" end, - project = function() return vim.fn.getcwd():match("([^/]+)$") end, - } +Templates Not Working~ +Checklist: +1. Verify `templates_path` exists and contains `.md` files +2. Check template syntax uses `{{variable}}` (not `{variable}`) +3. Ensure template file permissions are readable + +Links Not Following (gf not working)~ +Solution: Ensure you're using the correct link format: +- Correct: `[[note-name]]` or `[[note-name.md]]` +- Incorrect: `[note-name](note-name.md)` (standard markdown links) + +Performance Issues with Large Vaults~ +Solutions: +- Use `.gitignore` to exclude non-note files from searches +- Consider splitting large vaults into multiple workspaces +- Ensure fzf-lua is properly configured + +Debug Information~ + *markdown-notes-debug-info* +Check your configuration: > + :lua print(vim.inspect(require("markdown-notes").config)) < -============================================================================== -DIRECTORY STRUCTURE *markdown-notes-directory* - -Recommended directory structure: > - ~/repos/notes/ - ├── sys/ - │ └── templates/ - │ ├── Daily.md - │ ├── Meeting.md - │ └── Project.md - ├── personal/ - │ └── dailies/ - │ └── 2025/ - │ ├── 2025-01-01.md - │ └── 2025-01-02.md - └── notes/ - ├── project-ideas.md - └── learning-resources.md +Check current workspace: > + :MarkdownNotesWorkspaceStatus < ============================================================================== -LINK FORMATS *markdown-notes-link-formats* - -Wiki-style Links~ - *markdown-notes-wiki-links* -The plugin supports standard wiki-style links with the following formats: - -- `[[note-name]]` - Basic link to a note -- `[[note-name|display text]]` - Link with custom display text - -Link Resolution~ - *markdown-notes-link-resolution* -When following links with `gf`, the plugin uses fuzzy matching: - -1. First tries exact filename match: `note-name.md` -2. If not found, searches for files containing the link text: `*note-name*.md` -3. Opens the first match found - -Backlinks Detection~ - *markdown-notes-backlinks-detection* -The backlinks feature (`nb`) detects both: -- Basic links: `[[current-note]]` -- Links with display text: `[[current-note|custom text]]` - -============================================================================== -TROUBLESHOOTING *markdown-notes-troubleshooting* - -Common Issues~ - *markdown-notes-common-issues* - -fzf-lua not available~ -If you see "fzf-lua not available" errors, ensure fzf-lua is installed: -- Add `"ibhagwan/fzf-lua"` to your plugin manager dependencies -- Run `:checkhealth fzf-lua` to verify installation - -Template not found~ -If templates aren't loading: -- Verify `templates_path` in your configuration exists -- Ensure template files have `.md` extension -- Check file permissions on template directory - -No backlinks found~ -If backlinks aren't detected: -- Ensure links use exact `[[note-name]]` format (case-sensitive) -- Check that the current file is within your vault_path -- Verify linked files exist in your vault - -File previews not working~ -If file previews don't show: -- Ensure you have a compatible terminal with true color support -- Check that your colorscheme supports syntax highlighting -- Verify fzf-lua is properly configured - -Performance Issues~ - *markdown-notes-performance-issues* -For large vaults (>1000 files): -- Consider excluding certain directories from search -- Use more specific search terms -- Consider organizing notes into subdirectories - -============================================================================== -API *markdown-notes-api* +API REFERENCE *markdown-notes-api* +Setup Functions~ *markdown-notes.setup* require("markdown-notes").setup({opts}) - Setup function to configure the plugin. See |markdown-notes-configuration| - for available options. + Setup function to configure the plugin. See |markdown-notes-basic-config| + and |markdown-notes-advanced-config| for available options. *markdown-notes.setup_workspace* require("markdown-notes").setup_workspace(name, {opts}) Setup a workspace with the given name and configuration options. See |markdown-notes-workspaces| for details and examples. +Module API~ + *markdown-notes-module-api* The plugin exposes the following modules: - *markdown-notes.config* -require("markdown-notes.config") +require("markdown-notes.config") *markdown-notes.config* Configuration management module. - *markdown-notes.daily* -require("markdown-notes.daily") +require("markdown-notes.daily") *markdown-notes.daily* Daily notes functionality. - *markdown-notes.notes* -require("markdown-notes.notes") +require("markdown-notes.notes") *markdown-notes.notes* General note management. - *markdown-notes.links* -require("markdown-notes.links") +require("markdown-notes.links") *markdown-notes.links* Wiki-style links and backlinks. - *markdown-notes.templates* -require("markdown-notes.templates") +require("markdown-notes.templates") *markdown-notes.templates* Template system and variable substitution. - *markdown-notes.workspace* -require("markdown-notes.workspace") +require("markdown-notes.workspace") *markdown-notes.workspace* Workspace management and switching functionality. ============================================================================== diff --git a/doc/tags b/doc/tags index 281fa0e..0559b3d 100644 --- a/doc/tags +++ b/doc/tags @@ -1,39 +1,39 @@ +:MarkdownNotesRename markdown-notes.txt /*:MarkdownNotesRename* +:MarkdownNotesWorkspacePick markdown-notes.txt /*:MarkdownNotesWorkspacePick* +:MarkdownNotesWorkspaceStatus markdown-notes.txt /*:MarkdownNotesWorkspaceStatus* +:MarkdownNotesWorkspaceSwitch markdown-notes.txt /*:MarkdownNotesWorkspaceSwitch* markdown-notes markdown-notes.txt /*markdown-notes* +markdown-notes-advanced-config markdown-notes.txt /*markdown-notes-advanced-config* +markdown-notes-advanced-config-opts markdown-notes.txt /*markdown-notes-advanced-config-opts* +markdown-notes-advanced-directory-structure markdown-notes.txt /*markdown-notes-advanced-directory-structure* markdown-notes-api markdown-notes.txt /*markdown-notes-api* -markdown-notes-backlinks-detection markdown-notes.txt /*markdown-notes-backlinks-detection* +markdown-notes-basic-config markdown-notes.txt /*markdown-notes-basic-config* markdown-notes-commands markdown-notes.txt /*markdown-notes-commands* markdown-notes-common-issues markdown-notes.txt /*markdown-notes-common-issues* -markdown-notes-configuration markdown-notes.txt /*markdown-notes-configuration* markdown-notes-contents markdown-notes.txt /*markdown-notes-contents* -markdown-notes-dailies-path markdown-notes.txt /*markdown-notes-dailies-path* -markdown-notes-daily-note-naming markdown-notes.txt /*markdown-notes-daily-note-naming* -markdown-notes-daily-notes markdown-notes.txt /*markdown-notes-daily-notes* -markdown-notes-default-template markdown-notes.txt /*markdown-notes-default-template* -markdown-notes-directory markdown-notes.txt /*markdown-notes-directory* -markdown-notes-filename-format markdown-notes.txt /*markdown-notes-filename-format* +markdown-notes-debug-info markdown-notes.txt /*markdown-notes-debug-info* +markdown-notes-ex-commands markdown-notes.txt /*markdown-notes-ex-commands* +markdown-notes-function-commands markdown-notes.txt /*markdown-notes-function-commands* markdown-notes-installation markdown-notes.txt /*markdown-notes-installation* markdown-notes-introduction markdown-notes.txt /*markdown-notes-introduction* -markdown-notes-link-formats markdown-notes.txt /*markdown-notes-link-formats* -markdown-notes-link-resolution markdown-notes.txt /*markdown-notes-link-resolution* -markdown-notes-links-navigation markdown-notes.txt /*markdown-notes-links-navigation* -markdown-notes-mappings markdown-notes.txt /*markdown-notes-mappings* -markdown-notes-naming-benefits markdown-notes.txt /*markdown-notes-naming-benefits* -markdown-notes-note-management markdown-notes.txt /*markdown-notes-note-management* -markdown-notes-note-naming markdown-notes.txt /*markdown-notes-note-naming* -markdown-notes-notes-subdir markdown-notes.txt /*markdown-notes-notes-subdir* -markdown-notes-performance-issues markdown-notes.txt /*markdown-notes-performance-issues* +markdown-notes-key-mappings markdown-notes.txt /*markdown-notes-key-mappings* +markdown-notes-module-api markdown-notes.txt /*markdown-notes-module-api* +markdown-notes-quick-start markdown-notes.txt /*markdown-notes-quick-start* markdown-notes-requirements markdown-notes.txt /*markdown-notes-requirements* -markdown-notes-tags markdown-notes.txt /*markdown-notes-tags* -markdown-notes-template-vars markdown-notes.txt /*markdown-notes-template-vars* -markdown-notes-template-vars-config markdown-notes.txt /*markdown-notes-template-vars-config* -markdown-notes-templates markdown-notes.txt /*markdown-notes-templates* -markdown-notes-templates-path markdown-notes.txt /*markdown-notes-templates-path* +markdown-notes-template-built-in-vars markdown-notes.txt /*markdown-notes-template-built-in-vars* +markdown-notes-template-custom-vars markdown-notes.txt /*markdown-notes-template-custom-vars* +markdown-notes-template-examples markdown-notes.txt /*markdown-notes-template-examples* +markdown-notes-template-system markdown-notes.txt /*markdown-notes-template-system* markdown-notes-troubleshooting markdown-notes.txt /*markdown-notes-troubleshooting* -markdown-notes-usage markdown-notes.txt /*markdown-notes-usage* -markdown-notes-vault-path markdown-notes.txt /*markdown-notes-vault-path* -markdown-notes-weekly-path markdown-notes.txt /*markdown-notes-weekly-path* -markdown-notes-wiki-links markdown-notes.txt /*markdown-notes-wiki-links* -markdown-notes.apply_template_to_file markdown-notes.txt /*markdown-notes.apply_template_to_file* +markdown-notes-usage-daily-notes markdown-notes.txt /*markdown-notes-usage-daily-notes* +markdown-notes-usage-guide markdown-notes.txt /*markdown-notes-usage-guide* +markdown-notes-usage-links markdown-notes.txt /*markdown-notes-usage-links* +markdown-notes-usage-note-management markdown-notes.txt /*markdown-notes-usage-note-management* +markdown-notes-usage-templates markdown-notes.txt /*markdown-notes-usage-templates* +markdown-notes-workspace-commands markdown-notes.txt /*markdown-notes-workspace-commands* +markdown-notes-workspace-setup markdown-notes.txt /*markdown-notes-workspace-setup* +markdown-notes-workspace-workflow markdown-notes.txt /*markdown-notes-workspace-workflow* +markdown-notes-workspaces markdown-notes.txt /*markdown-notes-workspaces* markdown-notes.config markdown-notes.txt /*markdown-notes.config* markdown-notes.create_from_template markdown-notes.txt /*markdown-notes.create_from_template* markdown-notes.create_new_note markdown-notes.txt /*markdown-notes.create_new_note* @@ -45,10 +45,13 @@ markdown-notes.links markdown-notes.txt /*markdown-notes.links* markdown-notes.notes markdown-notes.txt /*markdown-notes.notes* markdown-notes.open_daily_note markdown-notes.txt /*markdown-notes.open_daily_note* markdown-notes.pick_template markdown-notes.txt /*markdown-notes.pick_template* +markdown-notes.rename_note markdown-notes.txt /*markdown-notes.rename_note* markdown-notes.search_and_link markdown-notes.txt /*markdown-notes.search_and_link* markdown-notes.search_notes markdown-notes.txt /*markdown-notes.search_notes* markdown-notes.search_tags markdown-notes.txt /*markdown-notes.search_tags* markdown-notes.setup markdown-notes.txt /*markdown-notes.setup* +markdown-notes.setup_workspace markdown-notes.txt /*markdown-notes.setup_workspace* markdown-notes.show_backlinks markdown-notes.txt /*markdown-notes.show_backlinks* markdown-notes.templates markdown-notes.txt /*markdown-notes.templates* markdown-notes.txt markdown-notes.txt /*markdown-notes.txt* +markdown-notes.workspace markdown-notes.txt /*markdown-notes.workspace* From a10192ac53f5549b87702b0691c7bc6add4f511c Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Sun, 6 Jul 2025 21:20:25 -0400 Subject: [PATCH 5/7] test: add comprehensive tests for user-defined template variables - Add config test for merging user template variables with defaults - Add integration test for config-defined template variables in substitution - Add test for custom variable override behavior - Verify both function and static value template variables work correctly --- tests/markdown-notes/config_spec.lua | 26 +++++++++++++ tests/markdown-notes/templates_spec.lua | 49 +++++++++++++++++++++++++ 2 files changed, 75 insertions(+) diff --git a/tests/markdown-notes/config_spec.lua b/tests/markdown-notes/config_spec.lua index 8c17649..c14ebed 100644 --- a/tests/markdown-notes/config_spec.lua +++ b/tests/markdown-notes/config_spec.lua @@ -42,6 +42,32 @@ describe("config", function() assert.is_not_nil(config.options.mappings.new_note) end) + it("merges user-defined template variables with defaults", function() + local user_opts = { + template_vars = { + author = function() return "Test Author" end, + project = function() return "test-project" end, + custom_string = "static-value" + } + } + + config.setup(user_opts) + + -- User variables should be present + assert.is_function(config.options.template_vars.author) + assert.is_function(config.options.template_vars.project) + assert.are.equal("static-value", config.options.template_vars.custom_string) + + -- Default variables should still be present + assert.is_function(config.options.template_vars.date) + assert.is_function(config.options.template_vars.time) + assert.is_function(config.options.template_vars.title) + + -- Test that user functions work + assert.are.equal("Test Author", config.options.template_vars.author()) + assert.are.equal("test-project", config.options.template_vars.project()) + end) + describe("workspaces", function() it("sets up workspace with custom config", function() local workspace_opts = { diff --git a/tests/markdown-notes/templates_spec.lua b/tests/markdown-notes/templates_spec.lua index d956625..fd0b013 100644 --- a/tests/markdown-notes/templates_spec.lua +++ b/tests/markdown-notes/templates_spec.lua @@ -42,5 +42,54 @@ describe("templates", function() assert.matches("%d%d%d%d%-%d%d%-%d%d", result[1]) assert.matches("%d%d:%d%d", result[1]) end) + + it("uses config-defined template variables", function() + -- Setup config with custom template variables + config.setup({ + template_vars = { + author = function() return "Test Author" end, + project = function() return "my-project" end, + custom_static = "static-content" + } + }) + + local content = { + "Author: {{author}}", + "Project: {{project}}", + "Static: {{custom_static}}", + "Date: {{date}}" + } + + local result = templates.substitute_template_vars(content) + + -- Custom variables should be substituted + assert.are.equal("Author: Test Author", result[1]) + assert.are.equal("Project: my-project", result[2]) + assert.are.equal("Static: static-content", result[3]) + + -- Default variables should still work + assert.matches("Date: %d%d%d%d%-%d%d%-%d%d", result[4]) + end) + + it("overrides config variables with custom vars parameter", function() + -- Setup config with a template variable + config.setup({ + template_vars = { + author = function() return "Config Author" end, + } + }) + + local content = {"Author: {{author}}"} + + -- Override with custom vars + local custom_vars = { + author = function() return "Override Author" end + } + + local result = templates.substitute_template_vars(content, custom_vars) + + -- Should use the override, not the config value + assert.are.equal("Author: Override Author", result[1]) + end) end) end) \ No newline at end of file From 57a53d5665e99f596ae6062638ba4210f6e70e26 Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Sun, 6 Jul 2025 22:31:41 -0400 Subject: [PATCH 6/7] Add comprehensive linting setup and enhanced GitHub workflow (#22) * feat: add luacheck linting with configuration - Add .luacheckrc with Neovim-specific linting rules - Add Makefile with lint, test, and utility targets - Configure appropriate warning ignores for plugin development - Set 100 character line limit for consistent formatting * fix: resolve all luacheck linting warnings and improve code quality - Fix logic issues by replacing inefficient loops with next() function calls - Break long lines to comply with 100 character limit - Remove trailing whitespace throughout codebase - Fix read-only field warnings in tests using proper metatable approach - Add test-setup.sh script for isolated testing environment - Achieve zero linting warnings across all Lua files * ci: add linting to GitHub Actions workflow and update contributing docs - Rename workflow from 'Tests' to 'CI' for broader scope - Add parallel lint job with luacheck installation - Update test job to use make commands for consistency - Enhance README contributing section with development tools documentation - Document all Makefile targets and CI integration --- .github/workflows/test.yml | 22 +- .luacheckrc | 45 ++ Makefile | 34 + README.md | 25 +- lua/markdown-notes/config.lua | 266 ++++---- lua/markdown-notes/daily.lua | 56 +- lua/markdown-notes/init.lua | 241 +++---- lua/markdown-notes/links.lua | 568 ++++++++--------- lua/markdown-notes/notes.lua | 449 ++++++------- lua/markdown-notes/templates.lua | 178 +++--- lua/markdown-notes/workspace.lua | 149 ++--- plugin/markdown-notes.lua | 4 +- test-setup.sh | 281 +++++++++ tests/markdown-notes/config_spec.lua | 485 ++++++++------- tests/markdown-notes/links_spec.lua | 796 ++++++++++++------------ tests/markdown-notes/notes_spec.lua | 286 +++++---- tests/markdown-notes/templates_spec.lua | 194 +++--- tests/markdown-notes/workspace_spec.lua | 118 ++-- tests/minimal_init.vim | 2 +- 19 files changed, 2329 insertions(+), 1870 deletions(-) create mode 100644 .luacheckrc create mode 100644 Makefile create mode 100755 test-setup.sh diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d3566d0..7d59a54 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,4 +1,4 @@ -name: Tests +name: CI on: push: @@ -7,6 +7,24 @@ on: branches: [ main, develop ] jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Install Lua and LuaRocks + run: | + sudo apt-get update + sudo apt-get install -y lua5.4 luarocks + + - name: Install luacheck + run: | + sudo luarocks install luacheck + + - name: Run linting + run: | + make lint + test: runs-on: ubuntu-latest strategy: @@ -29,4 +47,4 @@ jobs: - name: Run tests run: | - nvim --headless -c "PlenaryBustedDirectory tests/ { minimal_init = 'tests/minimal_init.vim' }" \ No newline at end of file + make test \ No newline at end of file diff --git a/.luacheckrc b/.luacheckrc new file mode 100644 index 0000000..5ce58f4 --- /dev/null +++ b/.luacheckrc @@ -0,0 +1,45 @@ +-- luacheck configuration for markdown-notes.nvim + +-- Use LuaJIT + Neovim standard library +std = "luajit" + +-- Add Neovim globals +globals = { + "vim", +} + +-- Additional read-only globals for testing +read_globals = { + -- Busted testing framework + "describe", "it", "before_each", "after_each", "setup", "teardown", + "assert", "spy", "stub", "mock", + -- Plenary testing + "require", +} + +-- Files/directories to exclude +exclude_files = { + ".luarocks/", + "doc/tags", +} + +-- Ignore specific warnings +ignore = { + "212", -- Unused argument (common in Neovim plugins for callback functions) + "213", -- Unused loop variable (common in ipairs/pairs loops) +} + +-- Maximum line length +max_line_length = 100 + +-- Files and their specific configurations +files = { + ["tests/"] = { + -- Allow longer lines in tests for readability + max_line_length = 120, + -- Additional testing globals + globals = { + "vim", -- vim is mocked in tests + } + } +} \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..bf331df --- /dev/null +++ b/Makefile @@ -0,0 +1,34 @@ +# Makefile for markdown-notes.nvim + +.PHONY: test lint lint-fix clean help + +# Default target +help: + @echo "Available targets:" + @echo " test - Run all tests" + @echo " lint - Run luacheck linter" + @echo " lint-fix - Run luacheck and show detailed issues for fixing" + @echo " clean - Clean up temporary files" + @echo " help - Show this help message" + +# Run tests +test: + nvim --headless -u tests/minimal_init.vim -c "lua require('plenary.test_harness').test_directory('tests')" + +# Run linter +lint: + luacheck lua/ tests/ + +# Run linter with detailed output for fixing +lint-fix: + luacheck --formatter plain --codes lua/ tests/ + +# Clean up +clean: + find . -name "*.tmp" -delete + find . -name "luacov.*" -delete + +# Check dependencies +check-deps: + @command -v luacheck >/dev/null 2>&1 || { echo "luacheck not found. Install with: luarocks install luacheck"; exit 1; } + @echo "✓ All dependencies available" \ No newline at end of file diff --git a/README.md b/README.md index 5b697fc..ec3934d 100644 --- a/README.md +++ b/README.md @@ -465,10 +465,31 @@ We welcome contributions! Here's how to get started: git clone https://github.com/yourusername/markdown-notes.nvim.git cd markdown-notes.nvim -# Run tests (requires plenary.nvim) -nvim --headless -u tests/minimal_init.vim -c "lua require('plenary.test_harness').test_directory('tests')" +# Install luacheck for linting (optional but recommended) +luarocks install luacheck + +# Run tests +make test + +# Run linting +make lint + +# Fix linting issues with detailed output +make lint-fix ``` +### Development Tools + +This project includes several development tools accessible via the Makefile: + +- `make test` - Run all tests using plenary.nvim +- `make lint` - Run luacheck linter on source and test files +- `make lint-fix` - Run luacheck with detailed output for fixing issues +- `make clean` - Clean up temporary files +- `make check-deps` - Verify required tools are installed + +The project uses GitHub Actions for CI, which automatically runs both tests and linting on all pull requests. + ### Reporting Issues - Use GitHub Issues for bug reports and feature requests diff --git a/lua/markdown-notes/config.lua b/lua/markdown-notes/config.lua index 1e9e8cf..817122f 100644 --- a/lua/markdown-notes/config.lua +++ b/lua/markdown-notes/config.lua @@ -1,43 +1,55 @@ local M = {} M.defaults = { - vault_path = "~/repos/notes", - templates_path = "~/repos/notes/sys/templates", - dailies_path = "~/repos/notes/personal/dailies/2025", - weekly_path = "~/repos/notes/personal/weekly", - notes_subdir = "notes", - default_template = nil, -- Optional default template for new notes - - -- Template substitution variables - template_vars = { - date = function() return os.date("%Y-%m-%d") end, - time = function() return os.date("%H:%M") end, - datetime = function() return os.date("%Y-%m-%d %H:%M") end, - title = function() return vim.fn.expand("%:t:r") end, - yesterday = function() return os.date("%Y-%m-%d", os.time() - 86400) end, - tomorrow = function() return os.date("%Y-%m-%d", os.time() + 86400) end, - }, - - -- Default workspace (optional) - default_workspace = nil, - - -- Key mappings - mappings = { - daily_note_today = "nd", - daily_note_yesterday = "ny", - daily_note_tomorrow = "nt", - new_note = "nn", - new_note_from_template = "nc", - find_notes = "nf", - search_notes = "ns", - insert_link = "nl", - insert_template = "np", - search_tags = "ng", - show_backlinks = "nb", - follow_link = "gf", - rename_note = "nr", - pick_workspace = "nw", - }, + vault_path = "~/repos/notes", + templates_path = "~/repos/notes/sys/templates", + dailies_path = "~/repos/notes/personal/dailies/2025", + weekly_path = "~/repos/notes/personal/weekly", + notes_subdir = "notes", + default_template = nil, -- Optional default template for new notes + + -- Template substitution variables + template_vars = { + date = function() + return os.date("%Y-%m-%d") + end, + time = function() + return os.date("%H:%M") + end, + datetime = function() + return os.date("%Y-%m-%d %H:%M") + end, + title = function() + return vim.fn.expand("%:t:r") + end, + yesterday = function() + return os.date("%Y-%m-%d", os.time() - 86400) + end, + tomorrow = function() + return os.date("%Y-%m-%d", os.time() + 86400) + end, + }, + + -- Default workspace (optional) + default_workspace = nil, + + -- Key mappings + mappings = { + daily_note_today = "nd", + daily_note_yesterday = "ny", + daily_note_tomorrow = "nt", + new_note = "nn", + new_note_from_template = "nc", + find_notes = "nf", + search_notes = "ns", + insert_link = "nl", + insert_template = "np", + search_tags = "ng", + show_backlinks = "nb", + follow_link = "gf", + rename_note = "nr", + pick_workspace = "nw", + }, } M.workspaces = {} @@ -46,122 +58,122 @@ M.current_active_workspace = nil M.options = {} local function deep_extend(target, source) - for k, v in pairs(source) do - if type(v) == "table" and type(target[k]) == "table" then - deep_extend(target[k], v) - else - target[k] = v - end - end - return target + for k, v in pairs(source) do + if type(v) == "table" and type(target[k]) == "table" then + deep_extend(target[k], v) + else + target[k] = v + end + end + return target end function M.setup(opts) - if vim and vim.tbl_deep_extend then - M.options = vim.tbl_deep_extend("force", M.defaults, opts or {}) - else - -- Fallback for test environment - M.options = {} - for k, v in pairs(M.defaults) do - M.options[k] = v - end - if opts then - deep_extend(M.options, opts) - end - end - - -- Set default workspace if specified in config - if M.options.default_workspace then - M.default_workspace = M.options.default_workspace - end + if vim and vim.tbl_deep_extend then + M.options = vim.tbl_deep_extend("force", M.defaults, opts or {}) + else + -- Fallback for test environment + M.options = {} + for k, v in pairs(M.defaults) do + M.options[k] = v + end + if opts then + deep_extend(M.options, opts) + end + end + + -- Set default workspace if specified in config + if M.options.default_workspace then + M.default_workspace = M.options.default_workspace + end end function M.setup_workspace(name, opts) - local workspace_config - if vim and vim.tbl_deep_extend then - workspace_config = vim.tbl_deep_extend("force", M.defaults, opts or {}) - else - workspace_config = {} - for k, v in pairs(M.defaults) do - workspace_config[k] = v - end - if opts then - deep_extend(workspace_config, opts) - end - end - M.workspaces[name] = workspace_config + local workspace_config + if vim and vim.tbl_deep_extend then + workspace_config = vim.tbl_deep_extend("force", M.defaults, opts or {}) + else + workspace_config = {} + for k, v in pairs(M.defaults) do + workspace_config[k] = v + end + if opts then + deep_extend(workspace_config, opts) + end + end + M.workspaces[name] = workspace_config end local function ensure_active_workspace() - -- If no active workspace set, use default workspace - if M.current_active_workspace == nil then - if M.default_workspace and M.workspaces[M.default_workspace] then - M.current_active_workspace = M.default_workspace - else - -- Fall back to first configured workspace - for name, _ in pairs(M.workspaces) do - M.current_active_workspace = name - break - end - - -- If no workspaces configured, create a "default" workspace from base config - if M.current_active_workspace == nil then - M.workspaces["default"] = M.options - M.current_active_workspace = "default" - end - end - end - - -- Validate current active workspace still exists - if not M.workspaces[M.current_active_workspace] then - if M.default_workspace and M.workspaces[M.default_workspace] then - M.current_active_workspace = M.default_workspace - else - -- Fall back to first workspace - for name, _ in pairs(M.workspaces) do - M.current_active_workspace = name - break - end - end - end + -- If no active workspace set, use default workspace + if M.current_active_workspace == nil then + if M.default_workspace and M.workspaces[M.default_workspace] then + M.current_active_workspace = M.default_workspace + else + -- Fall back to first configured workspace + local first_workspace_name = next(M.workspaces) + if first_workspace_name then + M.current_active_workspace = first_workspace_name + end + + -- If no workspaces configured, create a "default" workspace from base config + if M.current_active_workspace == nil then + M.workspaces["default"] = M.options + M.current_active_workspace = "default" + end + end + end + + -- Validate current active workspace still exists + if not M.workspaces[M.current_active_workspace] then + if M.default_workspace and M.workspaces[M.default_workspace] then + M.current_active_workspace = M.default_workspace + else + -- Fall back to first workspace + local first_workspace_name = next(M.workspaces) + if first_workspace_name then + M.current_active_workspace = first_workspace_name + end + end + end end function M.get_current_config(bufnr) - ensure_active_workspace() - -- Always return a workspace config (guaranteed to exist) - return M.workspaces[M.current_active_workspace], M.current_active_workspace + ensure_active_workspace() + -- Always return a workspace config (guaranteed to exist) + return M.workspaces[M.current_active_workspace], M.current_active_workspace end function M.get_workspaces() - return M.workspaces + return M.workspaces end function M.set_active_workspace(name) - if M.workspaces[name] then - M.current_active_workspace = name - return true - else - vim.notify("Workspace '" .. name .. "' not found", vim.log.levels.ERROR) - return false - end + if M.workspaces[name] then + M.current_active_workspace = name + return true + else + vim.notify("Workspace '" .. name .. "' not found", vim.log.levels.ERROR) + return false + end end function M.get_active_workspace() - return M.current_active_workspace + return M.current_active_workspace end function M.set_default_workspace(name) - if M.workspaces[name] then - M.default_workspace = name - return true - else - vim.notify("Workspace '" .. name .. "' not found", vim.log.levels.ERROR) - return false - end + if M.workspaces[name] then + M.default_workspace = name + return true + else + vim.notify("Workspace '" .. name .. "' not found", vim.log.levels.ERROR) + return false + end end function M.get_default_workspace() - return M.default_workspace + return M.default_workspace end -return M \ No newline at end of file +return M diff --git a/lua/markdown-notes/daily.lua b/lua/markdown-notes/daily.lua index 52f1bd0..df5defe 100644 --- a/lua/markdown-notes/daily.lua +++ b/lua/markdown-notes/daily.lua @@ -4,33 +4,33 @@ local templates = require("markdown-notes.templates") local M = {} function M.open_daily_note(offset) - offset = offset or 0 - local date = os.date("%Y-%m-%d", os.time() + (offset * 86400)) - local options = config.get_current_config() - local file_path = vim.fn.expand(options.dailies_path .. "/" .. date .. ".md") - - -- Create directory if it doesn't exist - local dir = vim.fn.fnamemodify(file_path, ":h") - if vim.fn.isdirectory(dir) == 0 then - vim.fn.mkdir(dir, "p") - end - - -- Create file with template if it doesn't exist - if vim.fn.filereadable(file_path) == 0 then - local template_path = vim.fn.expand(options.templates_path .. "/Daily.md") - if vim.fn.filereadable(template_path) == 1 then - local template_content = vim.fn.readfile(template_path) - local custom_vars = { - date = date, - title = date, - datetime = date .. " " .. os.date("%H:%M"), - } - template_content = templates.substitute_template_vars(template_content, custom_vars) - vim.fn.writefile(template_content, file_path) - end - end - - vim.cmd("edit " .. file_path) + offset = offset or 0 + local date = os.date("%Y-%m-%d", os.time() + (offset * 86400)) + local options = config.get_current_config() + local file_path = vim.fn.expand(options.dailies_path .. "/" .. date .. ".md") + + -- Create directory if it doesn't exist + local dir = vim.fn.fnamemodify(file_path, ":h") + if vim.fn.isdirectory(dir) == 0 then + vim.fn.mkdir(dir, "p") + end + + -- Create file with template if it doesn't exist + if vim.fn.filereadable(file_path) == 0 then + local template_path = vim.fn.expand(options.templates_path .. "/Daily.md") + if vim.fn.filereadable(template_path) == 1 then + local template_content = vim.fn.readfile(template_path) + local custom_vars = { + date = date, + title = date, + datetime = date .. " " .. os.date("%H:%M"), + } + template_content = templates.substitute_template_vars(template_content, custom_vars) + vim.fn.writefile(template_content, file_path) + end + end + + vim.cmd("edit " .. file_path) end -return M \ No newline at end of file +return M diff --git a/lua/markdown-notes/init.lua b/lua/markdown-notes/init.lua index cab5bcd..a134005 100644 --- a/lua/markdown-notes/init.lua +++ b/lua/markdown-notes/init.lua @@ -8,126 +8,143 @@ local workspace = require("markdown-notes.workspace") local M = {} function M.setup(opts) - config.setup(opts) - M.setup_keymaps() + config.setup(opts) + M.setup_keymaps() end function M.setup_workspace(name, opts) - config.setup_workspace(name, opts) - - -- If this is the first workspace and no default is set, make it the default - if not config.get_default_workspace() then - config.set_default_workspace(name) - end + config.setup_workspace(name, opts) + + -- If this is the first workspace and no default is set, make it the default + if not config.get_default_workspace() then + config.set_default_workspace(name) + end end function M.set_default_workspace(name) - return config.set_default_workspace(name) + return config.set_default_workspace(name) end function M.setup_keymaps() - - -- Set up key mappings - local function map(mode, key, cmd, desc) - -- Use a wrapper that gets current workspace config at runtime - local function wrapped_cmd() - if type(cmd) == "function" then - cmd() - else - return cmd - end - end - - if config.options.mappings[key] then - vim.keymap.set(mode, config.options.mappings[key], wrapped_cmd, { - noremap = true, - silent = true, - desc = desc - }) - end - end - - -- Daily notes - map("n", "daily_note_today", function() daily.open_daily_note(0) end, "Open today's note") - map("n", "daily_note_yesterday", function() daily.open_daily_note(-1) end, "Open yesterday's note") - map("n", "daily_note_tomorrow", function() daily.open_daily_note(1) end, "Open tomorrow's note") - - -- Note management - map("n", "new_note", notes.create_new_note, "Create new note") - map("n", "new_note_from_template", notes.create_from_template, "Create new note from template") - map("n", "find_notes", notes.find_notes, "Find notes") - map("n", "search_notes", notes.search_notes, "Search notes") - - -- Links - map("n", "insert_link", links.search_and_link, "Insert link to note") - map("n", "follow_link", links.follow_link, "Follow link") - map("n", "show_backlinks", links.show_backlinks, "Show backlinks") - map("n", "rename_note", function() - vim.ui.input({prompt = "New note name: "}, function(input) - if input then - links.rename_note(input) - end - end) - end, "Rename note and update links") - - -- Templates - map("n", "insert_template", templates.pick_template, "Insert template") - - -- Tags - map("n", "search_tags", notes.search_tags, "Search tags") - - -- Workspaces - map("n", "pick_workspace", workspace.pick_workspace, "Pick workspace") - - -- Note management commands - vim.api.nvim_create_user_command("MarkdownNotesRename", function(opts) - if opts.args and opts.args ~= "" then - links.rename_note(opts.args) - else - vim.ui.input({prompt = "New note name: "}, function(input) - if input then - links.rename_note(input) - end - end) - end - end, { nargs = "?", desc = "Rename current note and update links" }) - - -- Workspace management commands - vim.api.nvim_create_user_command("MarkdownNotesWorkspaceStatus", workspace.show_current_workspace, { desc = "Show current workspace" }) - vim.api.nvim_create_user_command("MarkdownNotesWorkspacePick", workspace.pick_workspace, { desc = "Pick workspace with fzf" }) - vim.api.nvim_create_user_command("MarkdownNotesWorkspaceSwitch", function(opts) - workspace.switch_to_workspace(opts.args) - end, { - nargs = 1, - desc = "Switch to workspace", - complete = function() - local workspaces = config.get_workspaces() - local names = {} - for name, _ in pairs(workspaces) do - table.insert(names, name) - end - return names - end - }) - vim.api.nvim_create_user_command("MarkdownNotesWorkspaceSetDefault", function(opts) - workspace.set_default_workspace(opts.args) - end, { - nargs = 1, - desc = "Set default workspace", - complete = function() - local workspaces = config.get_workspaces() - local names = {} - for name, _ in pairs(workspaces) do - table.insert(names, name) - end - return names - end - }) - vim.api.nvim_create_user_command("MarkdownNotesWorkspaceShowDefault", workspace.show_default_workspace, { desc = "Show default workspace" }) - vim.api.nvim_create_user_command("MarkdownNotesWorkspaceActive", function() - local _, active = config.get_current_config() - vim.notify("Active workspace: " .. active, vim.log.levels.INFO) - end, { desc = "Show active workspace" }) + -- Set up key mappings + local function map(mode, key, cmd, desc) + -- Use a wrapper that gets current workspace config at runtime + local function wrapped_cmd() + if type(cmd) == "function" then + cmd() + else + return cmd + end + end + + if config.options.mappings[key] then + vim.keymap.set(mode, config.options.mappings[key], wrapped_cmd, { + noremap = true, + silent = true, + desc = desc, + }) + end + end + + -- Daily notes + map("n", "daily_note_today", function() + daily.open_daily_note(0) + end, "Open today's note") + map("n", "daily_note_yesterday", function() + daily.open_daily_note(-1) + end, "Open yesterday's note") + map("n", "daily_note_tomorrow", function() + daily.open_daily_note(1) + end, "Open tomorrow's note") + + -- Note management + map("n", "new_note", notes.create_new_note, "Create new note") + map("n", "new_note_from_template", notes.create_from_template, "Create new note from template") + map("n", "find_notes", notes.find_notes, "Find notes") + map("n", "search_notes", notes.search_notes, "Search notes") + + -- Links + map("n", "insert_link", links.search_and_link, "Insert link to note") + map("n", "follow_link", links.follow_link, "Follow link") + map("n", "show_backlinks", links.show_backlinks, "Show backlinks") + map("n", "rename_note", function() + vim.ui.input({ prompt = "New note name: " }, function(input) + if input then + links.rename_note(input) + end + end) + end, "Rename note and update links") + + -- Templates + map("n", "insert_template", templates.pick_template, "Insert template") + + -- Tags + map("n", "search_tags", notes.search_tags, "Search tags") + + -- Workspaces + map("n", "pick_workspace", workspace.pick_workspace, "Pick workspace") + + -- Note management commands + vim.api.nvim_create_user_command("MarkdownNotesRename", function(opts) + if opts.args and opts.args ~= "" then + links.rename_note(opts.args) + else + vim.ui.input({ prompt = "New note name: " }, function(input) + if input then + links.rename_note(input) + end + end) + end + end, { nargs = "?", desc = "Rename current note and update links" }) + + -- Workspace management commands + vim.api.nvim_create_user_command( + "MarkdownNotesWorkspaceStatus", + workspace.show_current_workspace, + { desc = "Show current workspace" } + ) + vim.api.nvim_create_user_command( + "MarkdownNotesWorkspacePick", + workspace.pick_workspace, + { desc = "Pick workspace with fzf" } + ) + vim.api.nvim_create_user_command("MarkdownNotesWorkspaceSwitch", function(opts) + workspace.switch_to_workspace(opts.args) + end, { + nargs = 1, + desc = "Switch to workspace", + complete = function() + local workspaces = config.get_workspaces() + local names = {} + for name, _ in pairs(workspaces) do + table.insert(names, name) + end + return names + end, + }) + vim.api.nvim_create_user_command("MarkdownNotesWorkspaceSetDefault", function(opts) + workspace.set_default_workspace(opts.args) + end, { + nargs = 1, + desc = "Set default workspace", + complete = function() + local workspaces = config.get_workspaces() + local names = {} + for name, _ in pairs(workspaces) do + table.insert(names, name) + end + return names + end, + }) + vim.api.nvim_create_user_command( + "MarkdownNotesWorkspaceShowDefault", + workspace.show_default_workspace, + { desc = "Show default workspace" } + ) + vim.api.nvim_create_user_command("MarkdownNotesWorkspaceActive", function() + local _, active = config.get_current_config() + vim.notify("Active workspace: " .. active, vim.log.levels.INFO) + end, { desc = "Show active workspace" }) end -return M \ No newline at end of file +return M diff --git a/lua/markdown-notes/links.lua b/lua/markdown-notes/links.lua index 16cb889..458f2e9 100644 --- a/lua/markdown-notes/links.lua +++ b/lua/markdown-notes/links.lua @@ -4,298 +4,304 @@ local M = {} -- Helper function to insert a link at cursor position local function insert_link_at_cursor(file_path) - -- Remove .md extension but keep the full path - local link_path = file_path:gsub("%.md$", "") - local link = "[[" .. link_path .. "]]" - - -- Insert link at cursor - local cursor_pos = vim.api.nvim_win_get_cursor(0) - local line = vim.api.nvim_get_current_line() - local new_line = line:sub(1, cursor_pos[2]) .. link .. line:sub(cursor_pos[2] + 1) - vim.api.nvim_set_current_line(new_line) - vim.api.nvim_win_set_cursor(0, {cursor_pos[1], cursor_pos[2] + #link}) + -- Remove .md extension but keep the full path + local link_path = file_path:gsub("%.md$", "") + local link = "[[" .. link_path .. "]]" + + -- Insert link at cursor + local cursor_pos = vim.api.nvim_win_get_cursor(0) + local line = vim.api.nvim_get_current_line() + local new_line = line:sub(1, cursor_pos[2]) .. link .. line:sub(cursor_pos[2] + 1) + vim.api.nvim_set_current_line(new_line) + vim.api.nvim_win_set_cursor(0, { cursor_pos[1], cursor_pos[2] + #link }) end function M.search_and_link() - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - local options = config.get_current_config() - - fzf.files({ - prompt = "Link to Note> ", - cwd = vim.fn.expand(options.vault_path), - cmd = "find . -name '*.md' -type f -not -path '*/.*'", - file_icons = false, - path_shorten = false, - formatter = nil, - previewer = "builtin", - actions = { - ["default"] = function(selected) - if selected and #selected > 0 then - local file_path = vim.fn.expand(options.vault_path .. "/" .. selected[1]) - vim.cmd("edit " .. vim.fn.fnameescape(file_path)) - end - end, - ["ctrl-l"] = function(selected) - if selected and #selected > 0 then - insert_link_at_cursor(selected[1]) - end - end, - }, - }) + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + local options = config.get_current_config() + + fzf.files({ + prompt = "Link to Note> ", + cwd = vim.fn.expand(options.vault_path), + cmd = "find . -name '*.md' -type f -not -path '*/.*'", + file_icons = false, + path_shorten = false, + formatter = nil, + previewer = "builtin", + actions = { + ["default"] = function(selected) + if selected and #selected > 0 then + local file_path = vim.fn.expand(options.vault_path .. "/" .. selected[1]) + vim.cmd("edit " .. vim.fn.fnameescape(file_path)) + end + end, + ["ctrl-l"] = function(selected) + if selected and #selected > 0 then + insert_link_at_cursor(selected[1]) + end + end, + }, + }) end function M.follow_link() - local line = vim.api.nvim_get_current_line() - local col = vim.api.nvim_win_get_cursor(0)[2] - local options = config.get_current_config() - - -- Look for [[link]] pattern around cursor - local link_start = line:sub(1, col + 1):find("%[%[[^%]]*$") - if link_start then - local link_end = line:find("%]%]", col + 1) - if link_end then - local link_text = line:sub(link_start + 2, link_end - 1) - local file_path = vim.fn.expand(options.vault_path .. "/" .. link_text .. ".md") - - -- Try to find the file if exact match doesn't exist - if vim.fn.filereadable(file_path) == 0 then - local find_cmd = "find " .. vim.fn.expand(options.vault_path) .. " -name '*" .. link_text .. "*.md' -type f -not -path '*/.*'" - local found_files = vim.fn.systemlist(find_cmd) - if #found_files > 0 then - file_path = found_files[1] - end - end - - if vim.fn.filereadable(file_path) == 1 then - vim.cmd("edit " .. file_path) - else - vim.notify("File not found: " .. link_text, vim.log.levels.WARN) - end - return - end - end - - -- Fallback to default gf behavior - vim.cmd("normal! gf") + local line = vim.api.nvim_get_current_line() + local col = vim.api.nvim_win_get_cursor(0)[2] + local options = config.get_current_config() + + -- Look for [[link]] pattern around cursor + local link_start = line:sub(1, col + 1):find("%[%[[^%]]*$") + if link_start then + local link_end = line:find("%]%]", col + 1) + if link_end then + local link_text = line:sub(link_start + 2, link_end - 1) + local file_path = vim.fn.expand(options.vault_path .. "/" .. link_text .. ".md") + + -- Try to find the file if exact match doesn't exist + if vim.fn.filereadable(file_path) == 0 then + local find_cmd = "find " + .. vim.fn.expand(options.vault_path) + .. " -name '*" + .. link_text + .. "*.md' -type f -not -path '*/.*'" + local found_files = vim.fn.systemlist(find_cmd) + if #found_files > 0 then + file_path = found_files[1] + end + end + + if vim.fn.filereadable(file_path) == 1 then + vim.cmd("edit " .. file_path) + else + vim.notify("File not found: " .. link_text, vim.log.levels.WARN) + end + return + end + end + + -- Fallback to default gf behavior + vim.cmd("normal! gf") end function M.show_backlinks() - local current_path = vim.fn.expand("%:p") - local options = config.get_current_config() - local vault_path = vim.fn.expand(options.vault_path) - - -- Get relative path from vault root and remove .md extension - local relative_path = current_path:gsub("^" .. vim.pesc(vault_path) .. "/", ""):gsub("%.md$", "") - - if relative_path == "" then - vim.notify("No current file", vim.log.levels.WARN) - return - end - - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - - -- Find files that contain links to this note - local search_text = "[[" .. relative_path .. "]]" - - -- Get all markdown files first, then check each one - local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*'" - local all_files = vim.fn.systemlist(all_files_cmd) - - -- Remove ./ prefix from paths - for i, file in ipairs(all_files) do - all_files[i] = file:gsub("^%./", "") - end - - local linked_files = {} - for _, file in ipairs(all_files) do - local full_path = vault_path .. "/" .. file - local file_content = vim.fn.readfile(full_path) - local content_str = table.concat(file_content, "\n") - - -- Simple string search for the exact link - if content_str:find(search_text, 1, true) then - table.insert(linked_files, file) - end - - -- Also check for links with display text (|) - local link_with_display = "%[%[" .. vim.pesc(relative_path) .. "|" - if content_str:find(link_with_display) then - table.insert(linked_files, file) - end - end - - if #linked_files == 0 then - vim.notify("No backlinks found for: " .. relative_path, vim.log.levels.INFO) - return - end - - fzf.fzf_exec(linked_files, { - prompt = "Backlinks> ", - cwd = vault_path, - previewer = "builtin", - actions = { - ["default"] = function(selected) - if selected and #selected > 0 then - local file_path = vim.fn.expand(options.vault_path .. "/" .. selected[1]) - vim.cmd("edit " .. vim.fn.fnameescape(file_path)) - end - end, - ["ctrl-l"] = function(selected) - if selected and #selected > 0 then - insert_link_at_cursor(selected[1]) - end - end, - }, - }) + local current_path = vim.fn.expand("%:p") + local options = config.get_current_config() + local vault_path = vim.fn.expand(options.vault_path) + + -- Get relative path from vault root and remove .md extension + local relative_path = current_path:gsub("^" .. vim.pesc(vault_path) .. "/", ""):gsub("%.md$", "") + + if relative_path == "" then + vim.notify("No current file", vim.log.levels.WARN) + return + end + + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + + -- Find files that contain links to this note + local search_text = "[[" .. relative_path .. "]]" + + -- Get all markdown files first, then check each one + local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. + " && find . -name '*.md' -type f -not -path '*/.*'" + local all_files = vim.fn.systemlist(all_files_cmd) + + -- Remove ./ prefix from paths + for i, file in ipairs(all_files) do + all_files[i] = file:gsub("^%./", "") + end + + local linked_files = {} + for _, file in ipairs(all_files) do + local full_path = vault_path .. "/" .. file + local file_content = vim.fn.readfile(full_path) + local content_str = table.concat(file_content, "\n") + + -- Simple string search for the exact link + if content_str:find(search_text, 1, true) then + table.insert(linked_files, file) + end + + -- Also check for links with display text (|) + local link_with_display = "%[%[" .. vim.pesc(relative_path) .. "|" + if content_str:find(link_with_display) then + table.insert(linked_files, file) + end + end + + if #linked_files == 0 then + vim.notify("No backlinks found for: " .. relative_path, vim.log.levels.INFO) + return + end + + fzf.fzf_exec(linked_files, { + prompt = "Backlinks> ", + cwd = vault_path, + previewer = "builtin", + actions = { + ["default"] = function(selected) + if selected and #selected > 0 then + local file_path = vim.fn.expand(options.vault_path .. "/" .. selected[1]) + vim.cmd("edit " .. vim.fn.fnameescape(file_path)) + end + end, + ["ctrl-l"] = function(selected) + if selected and #selected > 0 then + insert_link_at_cursor(selected[1]) + end + end, + }, + }) end function M.rename_note(new_name) - local current_path = vim.fn.expand("%:p") - local options = config.get_current_config() - local vault_path = vim.fn.expand(options.vault_path) - - -- Get current note info - local relative_path = current_path:gsub("^" .. vim.pesc(vault_path) .. "/", ""):gsub("%.md$", "") - local current_dir = vim.fn.expand("%:p:h") - - if relative_path == "" then - vim.notify("No current file", vim.log.levels.WARN) - return - end - - -- Validate new name - if not new_name or new_name == "" then - vim.notify("New name cannot be empty", vim.log.levels.ERROR) - return - end - - -- Ensure new_name doesn't have .md extension - new_name = new_name:gsub("%.md$", "") - - -- Check for whitespace-only names - if new_name:match("^%s*$") then - vim.notify("New name cannot be only whitespace", vim.log.levels.ERROR) - return - end - - -- Check for invalid filename characters (basic check) - if new_name:match("[/\\:*?\"<>|]") then - vim.notify("New name contains invalid characters", vim.log.levels.ERROR) - return - end - - -- Create new file path - local new_file_path = current_dir .. "/" .. new_name .. ".md" - - -- Check if target file already exists - if vim.fn.filereadable(new_file_path) == 1 then - vim.notify("File already exists: " .. new_name .. ".md", vim.log.levels.ERROR) - return - end - - -- Find all files that link to this note - local search_text = "[[" .. relative_path .. "]]" - local link_with_display = "%[%[" .. vim.pesc(relative_path) .. "|" - - -- Get all markdown files - local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*'" - local all_files = vim.fn.systemlist(all_files_cmd) - - -- Remove ./ prefix from paths - for i, file in ipairs(all_files) do - all_files[i] = file:gsub("^%./", "") - end - - local files_to_update = {} - local update_count = 0 - - -- Find files with links to update - for _, file in ipairs(all_files) do - local full_path = vault_path .. "/" .. file - local file_content = vim.fn.readfile(full_path) - local content_str = table.concat(file_content, "\n") - local updated = false - - -- Check for exact link matches - if content_str:find(search_text, 1, true) then - updated = true - end - - -- Check for display text links - if content_str:find(link_with_display) then - updated = true - end - - if updated then - table.insert(files_to_update, {file = file, path = full_path}) - end - end - - -- Get new relative path for links - local current_dir_relative = current_dir:gsub("^" .. vim.pesc(vault_path) .. "/?", "") - local new_relative_path - if current_dir_relative == "" then - -- File is in vault root - new_relative_path = new_name - else - -- File is in subdirectory - new_relative_path = current_dir_relative .. "/" .. new_name - end - - -- Ask for confirmation - local message = "Rename '" .. relative_path .. "' to '" .. new_name .. "'" - if #files_to_update > 0 then - message = message .. " and update " .. #files_to_update .. " files with links?" - else - message = message .. "?" - end - - local confirm = vim.fn.confirm(message, "&Yes\n&No", 2) - if confirm ~= 1 then - return - end - - -- Update all linking files - for _, file_info in ipairs(files_to_update) do - local file_content = vim.fn.readfile(file_info.path) - local content_str = table.concat(file_content, "\n") - - -- Replace exact links using simple string replacement - local old_link = "[[" .. relative_path .. "]]" - local new_link = "[[" .. new_relative_path .. "]]" - content_str = content_str:gsub(vim.pesc(old_link), new_link) - - -- Replace display text links - local old_display_pattern = "(%[%[)" .. vim.pesc(relative_path) .. "(%|[^%]]*%]%])" - local new_display_replacement = "%1" .. new_relative_path .. "%2" - content_str = content_str:gsub(old_display_pattern, new_display_replacement) - - -- Write updated content - local updated_lines = vim.split(content_str, "\n") - vim.fn.writefile(updated_lines, file_info.path) - update_count = update_count + 1 - end - - -- Rename the actual file - local success = vim.fn.rename(current_path, new_file_path) - if success == 0 then - vim.cmd("edit " .. vim.fn.fnameescape(new_file_path)) - if update_count > 0 then - vim.notify("Renamed note and updated " .. update_count .. " files", vim.log.levels.INFO) - else - vim.notify("Renamed note (no links to update)", vim.log.levels.INFO) - end - else - vim.notify("Failed to rename file", vim.log.levels.ERROR) - end + local current_path = vim.fn.expand("%:p") + local options = config.get_current_config() + local vault_path = vim.fn.expand(options.vault_path) + + -- Get current note info + local relative_path = current_path:gsub("^" .. vim.pesc(vault_path) .. "/", ""):gsub("%.md$", "") + local current_dir = vim.fn.expand("%:p:h") + + if relative_path == "" then + vim.notify("No current file", vim.log.levels.WARN) + return + end + + -- Validate new name + if not new_name or new_name == "" then + vim.notify("New name cannot be empty", vim.log.levels.ERROR) + return + end + + -- Ensure new_name doesn't have .md extension + new_name = new_name:gsub("%.md$", "") + + -- Check for whitespace-only names + if new_name:match("^%s*$") then + vim.notify("New name cannot be only whitespace", vim.log.levels.ERROR) + return + end + + -- Check for invalid filename characters (basic check) + if new_name:match('[/\\:*?"<>|]') then + vim.notify("New name contains invalid characters", vim.log.levels.ERROR) + return + end + + -- Create new file path + local new_file_path = current_dir .. "/" .. new_name .. ".md" + + -- Check if target file already exists + if vim.fn.filereadable(new_file_path) == 1 then + vim.notify("File already exists: " .. new_name .. ".md", vim.log.levels.ERROR) + return + end + + -- Find all files that link to this note + local search_text = "[[" .. relative_path .. "]]" + local link_with_display = "%[%[" .. vim.pesc(relative_path) .. "|" + + -- Get all markdown files + local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. + " && find . -name '*.md' -type f -not -path '*/.*'" + local all_files = vim.fn.systemlist(all_files_cmd) + + -- Remove ./ prefix from paths + for i, file in ipairs(all_files) do + all_files[i] = file:gsub("^%./", "") + end + + local files_to_update = {} + local update_count = 0 + + -- Find files with links to update + for _, file in ipairs(all_files) do + local full_path = vault_path .. "/" .. file + local file_content = vim.fn.readfile(full_path) + local content_str = table.concat(file_content, "\n") + local updated = false + + -- Check for exact link matches + if content_str:find(search_text, 1, true) then + updated = true + end + + -- Check for display text links + if content_str:find(link_with_display) then + updated = true + end + + if updated then + table.insert(files_to_update, { file = file, path = full_path }) + end + end + + -- Get new relative path for links + local current_dir_relative = current_dir:gsub("^" .. vim.pesc(vault_path) .. "/?", "") + local new_relative_path + if current_dir_relative == "" then + -- File is in vault root + new_relative_path = new_name + else + -- File is in subdirectory + new_relative_path = current_dir_relative .. "/" .. new_name + end + + -- Ask for confirmation + local message = "Rename '" .. relative_path .. "' to '" .. new_name .. "'" + if #files_to_update > 0 then + message = message .. " and update " .. #files_to_update .. " files with links?" + else + message = message .. "?" + end + + local confirm = vim.fn.confirm(message, "&Yes\n&No", 2) + if confirm ~= 1 then + return + end + + -- Update all linking files + for _, file_info in ipairs(files_to_update) do + local file_content = vim.fn.readfile(file_info.path) + local content_str = table.concat(file_content, "\n") + + -- Replace exact links using simple string replacement + local old_link = "[[" .. relative_path .. "]]" + local new_link = "[[" .. new_relative_path .. "]]" + content_str = content_str:gsub(vim.pesc(old_link), new_link) + + -- Replace display text links + local old_display_pattern = "(%[%[)" .. vim.pesc(relative_path) .. "(%|[^%]]*%]%])" + local new_display_replacement = "%1" .. new_relative_path .. "%2" + content_str = content_str:gsub(old_display_pattern, new_display_replacement) + + -- Write updated content + local updated_lines = vim.split(content_str, "\n") + vim.fn.writefile(updated_lines, file_info.path) + update_count = update_count + 1 + end + + -- Rename the actual file + local success = vim.fn.rename(current_path, new_file_path) + if success == 0 then + vim.cmd("edit " .. vim.fn.fnameescape(new_file_path)) + if update_count > 0 then + vim.notify("Renamed note and updated " .. update_count .. " files", vim.log.levels.INFO) + else + vim.notify("Renamed note (no links to update)", vim.log.levels.INFO) + end + else + vim.notify("Failed to rename file", vim.log.levels.ERROR) + end end -return M \ No newline at end of file +return M diff --git a/lua/markdown-notes/notes.lua b/lua/markdown-notes/notes.lua index a159668..6380ef7 100644 --- a/lua/markdown-notes/notes.lua +++ b/lua/markdown-notes/notes.lua @@ -4,240 +4,243 @@ local templates = require("markdown-notes.templates") local M = {} function M.create_new_note() - local title = vim.fn.input("Note title (optional): ") - local options = config.get_current_config() - - -- Generate timestamp-based filename - local timestamp = tostring(os.time()) - local filename = timestamp - if title ~= "" then - local clean_title = title:gsub(" ", "-"):gsub("[^A-Za-z0-9-]", ""):lower() - filename = timestamp .. "-" .. clean_title - end - - local file_path = vim.fn.expand(options.vault_path .. "/" .. options.notes_subdir .. "/" .. filename .. ".md") - - -- Create directory if needed - local dir = vim.fn.fnamemodify(file_path, ":h") - if vim.fn.isdirectory(dir) == 0 then - vim.fn.mkdir(dir, "p") - end - - vim.cmd("edit " .. file_path) - - local display_title = title ~= "" and title or "Untitled" - - -- Use default template if configured, otherwise use basic frontmatter - if options.default_template then - local custom_vars = { - title = display_title, - note_title = display_title, - } - if not templates.apply_template_to_file(options.default_template, custom_vars) then - -- Fall back to basic frontmatter if template fails - local frontmatter = { - "---", - "title: " .. display_title, - "date: " .. os.date("%Y-%m-%d"), - "tags: []", - "---", - "", - "# " .. display_title, - "", - } - vim.api.nvim_buf_set_lines(0, 0, 0, false, frontmatter) - end - else - -- Insert basic frontmatter - local frontmatter = { - "---", - "title: " .. display_title, - "date: " .. os.date("%Y-%m-%d"), - "tags: []", - "---", - "", - "# " .. display_title, - "", - } - vim.api.nvim_buf_set_lines(0, 0, 0, false, frontmatter) - end + local title = vim.fn.input("Note title (optional): ") + local options = config.get_current_config() + + -- Generate timestamp-based filename + local timestamp = tostring(os.time()) + local filename = timestamp + if title ~= "" then + local clean_title = title:gsub(" ", "-"):gsub("[^A-Za-z0-9-]", ""):lower() + filename = timestamp .. "-" .. clean_title + end + + local file_path = vim.fn.expand(options.vault_path .. "/" .. + options.notes_subdir .. "/" .. filename .. ".md") + + -- Create directory if needed + local dir = vim.fn.fnamemodify(file_path, ":h") + if vim.fn.isdirectory(dir) == 0 then + vim.fn.mkdir(dir, "p") + end + + vim.cmd("edit " .. file_path) + + local display_title = title ~= "" and title or "Untitled" + + -- Use default template if configured, otherwise use basic frontmatter + if options.default_template then + local custom_vars = { + title = display_title, + note_title = display_title, + } + if not templates.apply_template_to_file(options.default_template, custom_vars) then + -- Fall back to basic frontmatter if template fails + local frontmatter = { + "---", + "title: " .. display_title, + "date: " .. os.date("%Y-%m-%d"), + "tags: []", + "---", + "", + "# " .. display_title, + "", + } + vim.api.nvim_buf_set_lines(0, 0, 0, false, frontmatter) + end + else + -- Insert basic frontmatter + local frontmatter = { + "---", + "title: " .. display_title, + "date: " .. os.date("%Y-%m-%d"), + "tags: []", + "---", + "", + "# " .. display_title, + "", + } + vim.api.nvim_buf_set_lines(0, 0, 0, false, frontmatter) + end end function M.create_from_template() - local title = vim.fn.input("Note title (optional): ") - local options = config.get_current_config() - - -- Generate timestamp-based filename - local timestamp = tostring(os.time()) - local filename = timestamp - if title ~= "" then - local clean_title = title:gsub(" ", "-"):gsub("[^A-Za-z0-9-]", ""):lower() - filename = timestamp .. "-" .. clean_title - end - - local file_path = vim.fn.expand(options.vault_path .. "/" .. options.notes_subdir .. "/" .. filename .. ".md") - - -- Create directory if needed - local dir = vim.fn.fnamemodify(file_path, ":h") - if vim.fn.isdirectory(dir) == 0 then - vim.fn.mkdir(dir, "p") - end - - vim.cmd("edit " .. file_path) - - local display_title = title ~= "" and title or "Untitled" - - -- Let user pick a template - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - - fzf.files({ - prompt = "Select Template> ", - cwd = vim.fn.expand(options.templates_path), - cmd = "find . -name '*.md' -type f -not -path '*/.*' -printf '%P\\n'", - file_icons = false, - path_shorten = false, - formatter = nil, - previewer = "builtin", - actions = { - ["default"] = function(selected) - if selected and #selected > 0 then - local template_name = vim.fn.fnamemodify(selected[1], ":t:r") - local custom_vars = { - title = display_title, - note_title = display_title, - } - templates.apply_template_to_file(template_name, custom_vars) - end - end, - }, - }) + local title = vim.fn.input("Note title (optional): ") + local options = config.get_current_config() + + -- Generate timestamp-based filename + local timestamp = tostring(os.time()) + local filename = timestamp + if title ~= "" then + local clean_title = title:gsub(" ", "-"):gsub("[^A-Za-z0-9-]", ""):lower() + filename = timestamp .. "-" .. clean_title + end + + local file_path = vim.fn.expand(options.vault_path .. "/" .. + options.notes_subdir .. "/" .. filename .. ".md") + + -- Create directory if needed + local dir = vim.fn.fnamemodify(file_path, ":h") + if vim.fn.isdirectory(dir) == 0 then + vim.fn.mkdir(dir, "p") + end + + vim.cmd("edit " .. file_path) + + local display_title = title ~= "" and title or "Untitled" + + -- Let user pick a template + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + + fzf.files({ + prompt = "Select Template> ", + cwd = vim.fn.expand(options.templates_path), + cmd = "find . -name '*.md' -type f -not -path '*/.*' -printf '%P\\n'", + file_icons = false, + path_shorten = false, + formatter = nil, + previewer = "builtin", + actions = { + ["default"] = function(selected) + if selected and #selected > 0 then + local template_name = vim.fn.fnamemodify(selected[1], ":t:r") + local custom_vars = { + title = display_title, + note_title = display_title, + } + templates.apply_template_to_file(template_name, custom_vars) + end + end, + }, + }) end function M.find_notes() - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - local options = config.get_current_config() - - fzf.files({ - prompt = "Find Notes> ", - cwd = vim.fn.expand(options.vault_path), - cmd = "find . -name '*.md' -type f -not -path '*/.*' -printf '%P\\n'", - previewer = "builtin", - }) + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + local options = config.get_current_config() + + fzf.files({ + prompt = "Find Notes> ", + cwd = vim.fn.expand(options.vault_path), + cmd = "find . -name '*.md' -type f -not -path '*/.*' -printf '%P\\n'", + previewer = "builtin", + }) end function M.search_notes() - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - local options = config.get_current_config() - - fzf.grep({ - prompt = "Search Notes> ", - cwd = vim.fn.expand(options.vault_path), - previewer = "builtin", - }) + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + local options = config.get_current_config() + + fzf.grep({ + prompt = "Search Notes> ", + cwd = vim.fn.expand(options.vault_path), + previewer = "builtin", + }) end function M.search_tags() - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - local options = config.get_current_config() - - local vault_path = vim.fn.expand(options.vault_path) - - -- Get all markdown files - local find_cmd = "find " .. vim.fn.shellescape(vault_path) .. " -name '*.md' -type f -not -path '*/.*'" - local all_files = vim.fn.systemlist(find_cmd) - - -- Extract all tags from frontmatter - local tags = {} - for _, file in ipairs(all_files) do - local content = vim.fn.readfile(file) - local in_frontmatter = false - - for _, line in ipairs(content) do - if line == "---" then - in_frontmatter = not in_frontmatter - elseif in_frontmatter and line:match("^tags:") then - -- Extract tags from YAML array format: tags: [tag1, tag2, tag3] - local tags_line = line:gsub("^tags:%s*", "") - if tags_line:match("^%[.*%]$") then - -- Remove brackets and split by comma - local tags_content = tags_line:gsub("^%[", ""):gsub("%]$", "") - for tag in tags_content:gmatch("[^,]+") do - local clean_tag = tag:gsub("%s", ""):gsub('"', ''):gsub("'", "") - if clean_tag ~= "" then - if not tags[clean_tag] then - tags[clean_tag] = {} - end - table.insert(tags[clean_tag], file) - end - end - end - break -- Only process first tags line in frontmatter - end - end - end - - -- Convert tags table to list for fzf - local tag_list = {} - for tag, files in pairs(tags) do - table.insert(tag_list, tag .. " (" .. #files .. " files)") - end - - if #tag_list == 0 then - vim.notify("No tags found in frontmatter", vim.log.levels.INFO) - return - end - - fzf.fzf_exec(tag_list, { - prompt = "Search Tags> ", - actions = { - ["default"] = function(selected) - if selected and #selected > 0 then - local tag = selected[1]:match("^([^%(]+)") - tag = tag:gsub("%s+$", "") -- trim trailing whitespace - local files_with_tag = tags[tag] - - if files_with_tag and #files_with_tag > 0 then - -- Show files with this tag - local relative_files = {} - for _, file in ipairs(files_with_tag) do - local relative = file:gsub("^" .. vim.pesc(vault_path) .. "/", "") - table.insert(relative_files, relative) - end - - fzf.fzf_exec(relative_files, { - prompt = "Files with tag '" .. tag .. "'> ", - cwd = vault_path, - previewer = "builtin", - actions = { - ["default"] = function(file_selected) - if file_selected and #file_selected > 0 then - local file_path = vim.fn.expand(vault_path .. "/" .. file_selected[1]) - vim.cmd("edit " .. vim.fn.fnameescape(file_path)) - end - end, - }, - }) - end - end - end, - }, - }) + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + local options = config.get_current_config() + + local vault_path = vim.fn.expand(options.vault_path) + + -- Get all markdown files + local find_cmd = "find " .. vim.fn.shellescape(vault_path) .. + " -name '*.md' -type f -not -path '*/.*'" + local all_files = vim.fn.systemlist(find_cmd) + + -- Extract all tags from frontmatter + local tags = {} + for _, file in ipairs(all_files) do + local content = vim.fn.readfile(file) + local in_frontmatter = false + + for _, line in ipairs(content) do + if line == "---" then + in_frontmatter = not in_frontmatter + elseif in_frontmatter and line:match("^tags:") then + -- Extract tags from YAML array format: tags: [tag1, tag2, tag3] + local tags_line = line:gsub("^tags:%s*", "") + if tags_line:match("^%[.*%]$") then + -- Remove brackets and split by comma + local tags_content = tags_line:gsub("^%[", ""):gsub("%]$", "") + for tag in tags_content:gmatch("[^,]+") do + local clean_tag = tag:gsub("%s", ""):gsub('"', ""):gsub("'", "") + if clean_tag ~= "" then + if not tags[clean_tag] then + tags[clean_tag] = {} + end + table.insert(tags[clean_tag], file) + end + end + end + break -- Only process first tags line in frontmatter + end + end + end + + -- Convert tags table to list for fzf + local tag_list = {} + for tag, files in pairs(tags) do + table.insert(tag_list, tag .. " (" .. #files .. " files)") + end + + if #tag_list == 0 then + vim.notify("No tags found in frontmatter", vim.log.levels.INFO) + return + end + + fzf.fzf_exec(tag_list, { + prompt = "Search Tags> ", + actions = { + ["default"] = function(selected) + if selected and #selected > 0 then + local tag = selected[1]:match("^([^%(]+)") + tag = tag:gsub("%s+$", "") -- trim trailing whitespace + local files_with_tag = tags[tag] + + if files_with_tag and #files_with_tag > 0 then + -- Show files with this tag + local relative_files = {} + for _, file in ipairs(files_with_tag) do + local relative = file:gsub("^" .. vim.pesc(vault_path) .. "/", "") + table.insert(relative_files, relative) + end + + fzf.fzf_exec(relative_files, { + prompt = "Files with tag '" .. tag .. "'> ", + cwd = vault_path, + previewer = "builtin", + actions = { + ["default"] = function(file_selected) + if file_selected and #file_selected > 0 then + local file_path = vim.fn.expand(vault_path .. "/" .. file_selected[1]) + vim.cmd("edit " .. vim.fn.fnameescape(file_path)) + end + end, + }, + }) + end + end + end, + }, + }) end -return M \ No newline at end of file +return M diff --git a/lua/markdown-notes/templates.lua b/lua/markdown-notes/templates.lua index f2bce74..7fdd704 100644 --- a/lua/markdown-notes/templates.lua +++ b/lua/markdown-notes/templates.lua @@ -3,103 +3,103 @@ local config = require("markdown-notes.config") local M = {} function M.substitute_template_vars(content, custom_vars) - local options = config.get_current_config() - -- Fallback to config.options if no workspace config available - if not options then - options = config.options - end - local template_vars = options.template_vars or config.defaults.template_vars - local vars = {} - - -- Manual merge since vim.tbl_extend might not be available in tests - for k, v in pairs(template_vars) do - vars[k] = v - end - - if custom_vars then - for k, v in pairs(custom_vars) do - vars[k] = v - end - end - - for i, line in ipairs(content) do - for var_name, var_func in pairs(vars) do - local pattern = "{{" .. var_name .. "}}" - local replacement = type(var_func) == "function" and var_func() or var_func - content[i] = string.gsub(content[i], pattern, replacement) - end - end - - return content + local options = config.get_current_config() + -- Fallback to config.options if no workspace config available + if not options then + options = config.options + end + local template_vars = options.template_vars or config.defaults.template_vars + local vars = {} + + -- Manual merge since vim.tbl_extend might not be available in tests + for k, v in pairs(template_vars) do + vars[k] = v + end + + if custom_vars then + for k, v in pairs(custom_vars) do + vars[k] = v + end + end + + for i, line in ipairs(content) do + for var_name, var_func in pairs(vars) do + local pattern = "{{" .. var_name .. "}}" + local replacement = type(var_func) == "function" and var_func() or var_func + content[i] = string.gsub(content[i], pattern, replacement) + end + end + + return content end function M.insert_template(template_name, custom_vars) - local options = config.get_current_config() - if not options then - options = config.options - end - local template_path = vim.fn.expand(options.templates_path .. "/" .. template_name .. ".md") - - if vim.fn.filereadable(template_path) == 0 then - vim.notify("Template not found: " .. template_path, vim.log.levels.ERROR) - return - end - - local template_content = vim.fn.readfile(template_path) - template_content = M.substitute_template_vars(template_content, custom_vars) - - local cursor_pos = vim.api.nvim_win_get_cursor(0) - vim.api.nvim_buf_set_lines(0, cursor_pos[1] - 1, cursor_pos[1] - 1, false, template_content) + local options = config.get_current_config() + if not options then + options = config.options + end + local template_path = vim.fn.expand(options.templates_path .. "/" .. template_name .. ".md") + + if vim.fn.filereadable(template_path) == 0 then + vim.notify("Template not found: " .. template_path, vim.log.levels.ERROR) + return + end + + local template_content = vim.fn.readfile(template_path) + template_content = M.substitute_template_vars(template_content, custom_vars) + + local cursor_pos = vim.api.nvim_win_get_cursor(0) + vim.api.nvim_buf_set_lines(0, cursor_pos[1] - 1, cursor_pos[1] - 1, false, template_content) end function M.apply_template_to_file(template_name, custom_vars) - local options = config.get_current_config() - if not options then - options = config.options - end - local template_path = vim.fn.expand(options.templates_path .. "/" .. template_name .. ".md") - - if vim.fn.filereadable(template_path) == 0 then - vim.notify("Template not found: " .. template_path, vim.log.levels.ERROR) - return false - end - - local template_content = vim.fn.readfile(template_path) - template_content = M.substitute_template_vars(template_content, custom_vars) - - -- Replace entire buffer content - vim.api.nvim_buf_set_lines(0, 0, -1, false, template_content) - return true + local options = config.get_current_config() + if not options then + options = config.options + end + local template_path = vim.fn.expand(options.templates_path .. "/" .. template_name .. ".md") + + if vim.fn.filereadable(template_path) == 0 then + vim.notify("Template not found: " .. template_path, vim.log.levels.ERROR) + return false + end + + local template_content = vim.fn.readfile(template_path) + template_content = M.substitute_template_vars(template_content, custom_vars) + + -- Replace entire buffer content + vim.api.nvim_buf_set_lines(0, 0, -1, false, template_content) + return true end function M.pick_template() - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - local options = config.get_current_config() - if not options then - options = config.options - end - - fzf.files({ - prompt = "Select Template> ", - cwd = vim.fn.expand(options.templates_path), - cmd = "find . -name '*.md' -type f -not -path '*/.*'", - file_icons = false, - path_shorten = false, - formatter = nil, - previewer = "builtin", - actions = { - ["default"] = function(selected) - if selected and #selected > 0 then - local template_name = vim.fn.fnamemodify(selected[1], ":t:r") - M.insert_template(template_name) - end - end, - }, - }) + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + local options = config.get_current_config() + if not options then + options = config.options + end + + fzf.files({ + prompt = "Select Template> ", + cwd = vim.fn.expand(options.templates_path), + cmd = "find . -name '*.md' -type f -not -path '*/.*'", + file_icons = false, + path_shorten = false, + formatter = nil, + previewer = "builtin", + actions = { + ["default"] = function(selected) + if selected and #selected > 0 then + local template_name = vim.fn.fnamemodify(selected[1], ":t:r") + M.insert_template(template_name) + end + end, + }, + }) end -return M \ No newline at end of file +return M diff --git a/lua/markdown-notes/workspace.lua b/lua/markdown-notes/workspace.lua index fe91428..ebfec60 100644 --- a/lua/markdown-notes/workspace.lua +++ b/lua/markdown-notes/workspace.lua @@ -2,94 +2,97 @@ local config = require("markdown-notes.config") local M = {} - function M.show_current_workspace() - local options, current_workspace = config.get_current_config() - local default_workspace = config.get_default_workspace() - - if current_workspace then - local default_indicator = (current_workspace == default_workspace) and " (default)" or "" - vim.notify("Current workspace: " .. current_workspace .. default_indicator .. " (" .. options.vault_path .. ")", vim.log.levels.INFO) - else - vim.notify("Using fallback configuration (no workspace detected)", vim.log.levels.INFO) - end + local options, current_workspace = config.get_current_config() + local default_workspace = config.get_default_workspace() + + if current_workspace then + local default_indicator = (current_workspace == default_workspace) and " (default)" or "" + vim.notify( + "Current workspace: " .. current_workspace .. default_indicator .. + " (" .. options.vault_path .. ")", + vim.log.levels.INFO + ) + else + vim.notify("Using fallback configuration (no workspace detected)", vim.log.levels.INFO) + end end function M.set_default_workspace(workspace_name) - if config.set_default_workspace(workspace_name) then - vim.notify("Set default workspace to: " .. workspace_name, vim.log.levels.INFO) - end + if config.set_default_workspace(workspace_name) then + vim.notify("Set default workspace to: " .. workspace_name, vim.log.levels.INFO) + end end function M.set_active_workspace(workspace_name) - if config.set_active_workspace(workspace_name) then - local workspace = config.get_workspaces()[workspace_name] - local vault_path = vim.fn.expand(workspace.vault_path) - vim.cmd("cd " .. vim.fn.fnameescape(vault_path)) - vim.notify("Switched to workspace: " .. workspace_name, vim.log.levels.INFO) - end + if config.set_active_workspace(workspace_name) then + local workspace = config.get_workspaces()[workspace_name] + local vault_path = vim.fn.expand(workspace.vault_path) + vim.cmd("cd " .. vim.fn.fnameescape(vault_path)) + vim.notify("Switched to workspace: " .. workspace_name, vim.log.levels.INFO) + end end function M.show_default_workspace() - local default_workspace = config.get_default_workspace() - if default_workspace then - vim.notify("Default workspace: " .. default_workspace, vim.log.levels.INFO) - else - vim.notify("No default workspace set", vim.log.levels.INFO) - end + local default_workspace = config.get_default_workspace() + if default_workspace then + vim.notify("Default workspace: " .. default_workspace, vim.log.levels.INFO) + else + vim.notify("No default workspace set", vim.log.levels.INFO) + end end function M.switch_to_workspace(workspace_name) - local workspaces = config.get_workspaces() - - if not workspaces[workspace_name] then - vim.notify("Workspace '" .. workspace_name .. "' not found", vim.log.levels.ERROR) - return - end - - local workspace = workspaces[workspace_name] - local vault_path = vim.fn.expand(workspace.vault_path) - - if vim.fn.isdirectory(vault_path) == 0 then - vim.notify("Workspace directory does not exist: " .. vault_path, vim.log.levels.ERROR) - return - end - - -- Set as active workspace and change directory - M.set_active_workspace(workspace_name) + local workspaces = config.get_workspaces() + + if not workspaces[workspace_name] then + vim.notify("Workspace '" .. workspace_name .. "' not found", vim.log.levels.ERROR) + return + end + + local workspace = workspaces[workspace_name] + local vault_path = vim.fn.expand(workspace.vault_path) + + if vim.fn.isdirectory(vault_path) == 0 then + vim.notify("Workspace directory does not exist: " .. vault_path, vim.log.levels.ERROR) + return + end + + -- Set as active workspace and change directory + M.set_active_workspace(workspace_name) end function M.pick_workspace() - local workspaces = config.get_workspaces() - - if vim.tbl_isempty(workspaces) then - vim.notify("No workspaces configured", vim.log.levels.INFO) - return - end - - local ok, fzf = pcall(require, "fzf-lua") - if not ok then - vim.notify("fzf-lua not available", vim.log.levels.ERROR) - return - end - - local workspace_list = {} - for name, workspace in pairs(workspaces) do - table.insert(workspace_list, name .. " - " .. workspace.vault_path) - end - - fzf.fzf_exec(workspace_list, { - prompt = "Select Workspace> ", - actions = { - ["default"] = function(selected) - if selected and #selected > 0 then - local workspace_name = selected[1]:match("^([^%-]+)") - workspace_name = workspace_name:gsub("%s+$", "") -- trim trailing whitespace - M.switch_to_workspace(workspace_name) - end - end, - }, - }) + local workspaces = config.get_workspaces() + + if vim.tbl_isempty(workspaces) then + vim.notify("No workspaces configured", vim.log.levels.INFO) + return + end + + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + + local workspace_list = {} + for name, workspace in pairs(workspaces) do + table.insert(workspace_list, name .. " - " .. workspace.vault_path) + end + + fzf.fzf_exec(workspace_list, { + prompt = "Select Workspace> ", + actions = { + ["default"] = function(selected) + if selected and #selected > 0 then + local workspace_name = selected[1]:match("^([^%-]+)") + workspace_name = workspace_name:gsub("%s+$", "") -- trim trailing whitespace + M.switch_to_workspace(workspace_name) + end + end, + }, + }) end -return M \ No newline at end of file +return M diff --git a/plugin/markdown-notes.lua b/plugin/markdown-notes.lua index 874bf82..e25c89e 100644 --- a/plugin/markdown-notes.lua +++ b/plugin/markdown-notes.lua @@ -1,6 +1,6 @@ if vim.g.loaded_markdown_notes == 1 then - return + return end vim.g.loaded_markdown_notes = 1 --- Plugin will be set up via require('markdown-notes').setup() in user config \ No newline at end of file +-- Plugin will be set up via require('markdown-notes').setup() in user config diff --git a/test-setup.sh b/test-setup.sh new file mode 100755 index 0000000..ba4cfaf --- /dev/null +++ b/test-setup.sh @@ -0,0 +1,281 @@ +#!/bin/bash + +# markdown-notes.nvim Test Setup Script +# Creates a clean testing environment for the plugin + +set -e + +echo "đŸ§Ē Setting up markdown-notes.nvim test environment..." + +# Configuration +TEST_DIR="$HOME/test-markdown-notes" +CONFIG_FILE="$TEST_DIR/test-config.lua" + +# Clean up existing test directory +if [ -d "$TEST_DIR" ]; then + echo "🧹 Cleaning up existing test directory..." + rm -rf "$TEST_DIR" +fi + +# Create test directory structure +echo "📁 Creating test directory structure..." +mkdir -p "$TEST_DIR"/{vault/{templates,daily,notes},config} + +# Create test templates +echo "📝 Creating test templates..." + +# Basic template +cat > "$TEST_DIR/vault/templates/basic.md" << 'EOF' +--- +title: {{title}} +date: {{date}} +tags: [] +--- + +# {{title}} + +Created: {{datetime}} + +## Notes + +EOF + +# Daily template +cat > "$TEST_DIR/vault/templates/Daily.md" << 'EOF' +--- +title: Daily Note - {{date}} +date: {{date}} +tags: [daily] +--- + +# {{date}} - Daily Notes + +## đŸŽ¯ Today's Goals +- [ ] + +## 📝 Notes + +## 🔄 Tomorrow's Prep +- [ ] + +EOF + +# Meeting template +cat > "$TEST_DIR/vault/templates/meeting.md" << 'EOF' +--- +title: {{title}} +date: {{date}} +tags: [meeting] +attendees: [] +--- + +# {{title}} + +**Date:** {{datetime}} +**Attendees:** + +## Agenda + +## Notes + +## Action Items +- [ ] + +EOF + +# Project template +cat > "$TEST_DIR/vault/templates/project.md" << 'EOF' +--- +title: {{title}} +date: {{date}} +tags: [project] +status: planning +--- + +# {{title}} + +**Created:** {{datetime}} + +## Overview + +## Goals + +## Tasks +- [ ] + +## Resources + +EOF + +# Create minimal test configuration +echo "⚙ī¸ Creating test configuration..." +cat > "$CONFIG_FILE" << EOF +-- Test configuration for markdown-notes.nvim +-- Run with: nvim -u $CONFIG_FILE + +-- Minimal vim setup +vim.cmd('set runtimepath^=~/.vim runtimepath+=~/.vim/after') +vim.cmd('let &packpath = &runtimepath') + +-- Add current plugin directory to runtime path +vim.opt.rtp:prepend('$(pwd)') + +-- Try to add fzf-lua from common locations +local fzf_paths = { + vim.fn.expand('~/.local/share/nvim/lazy/fzf-lua'), + vim.fn.expand('~/.local/share/nvim/site/pack/*/start/fzf-lua'), + vim.fn.expand('~/.config/nvim/pack/*/start/fzf-lua'), +} + +for _, path in ipairs(fzf_paths) do + if vim.fn.isdirectory(path) == 1 then + vim.opt.rtp:prepend(path) + print('đŸ“Ļ Found fzf-lua at: ' .. path) + break + end +end + +-- Set leader key +vim.g.mapleader = ' ' + +-- Basic settings for testing +vim.opt.number = true +vim.opt.relativenumber = true +vim.opt.wrap = false + +-- Setup markdown-notes +local ok, markdown_notes = pcall(require, 'markdown-notes') +if not ok then + print('❌ Failed to load markdown-notes: ' .. tostring(markdown_notes)) + return +end + +markdown_notes.setup({ + vault_path = '$TEST_DIR/vault', + templates_path = '$TEST_DIR/vault/templates', + dailies_path = '$TEST_DIR/vault/daily', + notes_subdir = 'notes', + default_template = 'basic', +}) + +print('✅ markdown-notes.nvim loaded successfully!') +print('📁 Test vault: $TEST_DIR/vault') +print('') +print('đŸ§Ē Test Commands:') +print(' nd - Create daily note') +print(' nn - Create new note') +print(' nc - Create from template') +print(' nf - Find notes') +print(' ns - Search notes') +print(' np - Insert template') +print(' :help markdown-notes - View documentation') +print('') +print('📂 Available templates:') +print(' - basic.md') +print(' - Daily.md') +print(' - meeting.md') +print(' - project.md') +print('') +print('🔧 To inspect config: :lua print(vim.inspect(require("markdown-notes.config").options))') +EOF + +# Create some sample notes for testing +echo "📄 Creating sample notes..." + +cat > "$TEST_DIR/vault/notes/welcome.md" << 'EOF' +--- +title: Welcome to Test Notes +date: 2025-01-06 +tags: [welcome, test] +--- + +# Welcome to Test Notes + +This is a sample note for testing the markdown-notes.nvim plugin. + +## Features to Test + +- [[daily-workflow]] - Link to daily workflow +- [[project-management]] - Link to project management +- Create new notes with templates +- Search functionality + +## Sample Links + +Try following these links with `gf`: +- [[welcome]] (this note) +- [[nonexistent-note]] (will create new note) + +EOF + +cat > "$TEST_DIR/vault/notes/daily-workflow.md" << 'EOF' +--- +title: Daily Workflow +date: 2025-01-06 +tags: [workflow, daily] +--- + +# Daily Workflow + +This note demonstrates the daily workflow with markdown-notes.nvim. + +## Morning Routine +1. Open daily note with `nd` +2. Review yesterday's note with `ny` +3. Plan today's tasks + +## Evening Review +1. Update daily note +2. Plan tomorrow with `nt` + +This note links back to [[welcome]]. + +EOF + +# Create launch script +echo "🚀 Creating launch script..." +cat > "$TEST_DIR/launch-test.sh" << EOF +#!/bin/bash +echo "đŸ§Ē Launching markdown-notes.nvim test environment..." +echo "📁 Test vault: $TEST_DIR/vault" +echo "" +cd '$TEST_DIR/vault' +nvim -u '$CONFIG_FILE' +EOF + +chmod +x "$TEST_DIR/launch-test.sh" + +# Create cleanup script +cat > "$TEST_DIR/cleanup.sh" << EOF +#!/bin/bash +echo "🧹 Cleaning up test environment..." +rm -rf '$TEST_DIR' +echo "✅ Test environment cleaned up!" +EOF + +chmod +x "$TEST_DIR/cleanup.sh" + +echo "" +echo "✅ Test environment setup complete!" +echo "" +echo "🚀 To start testing:" +echo " $TEST_DIR/launch-test.sh" +echo "" +echo "📁 Test vault location:" +echo " $TEST_DIR/vault" +echo "" +echo "⚙ī¸ Config file:" +echo " $CONFIG_FILE" +echo "" +echo "🧹 To cleanup when done:" +echo " $TEST_DIR/cleanup.sh" +echo "" +echo "📋 Test checklist:" +echo " □ Daily notes (nd, ny, nt)" +echo " □ New notes (nn, nc)" +echo " □ Finding notes (nf)" +echo " □ Searching content (ns)" +echo " □ Following links (gf on [[links]])" +echo " □ Inserting templates (np)" +echo " □ Help documentation (:help markdown-notes)" +echo " □ Workspace functionality" \ No newline at end of file diff --git a/tests/markdown-notes/config_spec.lua b/tests/markdown-notes/config_spec.lua index c14ebed..d83ad1a 100644 --- a/tests/markdown-notes/config_spec.lua +++ b/tests/markdown-notes/config_spec.lua @@ -1,245 +1,246 @@ local config = require("markdown-notes.config") describe("config", function() - before_each(function() - config.options = {} - config.workspaces = {} - config.default_workspace = nil - config.current_active_workspace = nil - end) - - it("has default configuration", function() - assert.is_not_nil(config.defaults) - assert.is_not_nil(config.defaults.vault_path) - assert.is_not_nil(config.defaults.templates_path) - assert.is_not_nil(config.defaults.template_vars) - assert.is_not_nil(config.defaults.mappings) - end) - - it("merges user options with defaults", function() - local user_opts = { - vault_path = "/custom/path", - custom_option = "test" - } - - config.setup(user_opts) - - assert.are.equal("/custom/path", config.options.vault_path) - assert.are.equal("test", config.options.custom_option) - assert.is_not_nil(config.options.templates_path) - end) - - it("deep merges nested options", function() - local user_opts = { - mappings = { - daily_note_today = "dt" - } - } - - config.setup(user_opts) - - assert.are.equal("dt", config.options.mappings.daily_note_today) - assert.is_not_nil(config.options.mappings.new_note) - end) - - it("merges user-defined template variables with defaults", function() - local user_opts = { - template_vars = { - author = function() return "Test Author" end, - project = function() return "test-project" end, - custom_string = "static-value" - } - } - - config.setup(user_opts) - - -- User variables should be present - assert.is_function(config.options.template_vars.author) - assert.is_function(config.options.template_vars.project) - assert.are.equal("static-value", config.options.template_vars.custom_string) - - -- Default variables should still be present - assert.is_function(config.options.template_vars.date) - assert.is_function(config.options.template_vars.time) - assert.is_function(config.options.template_vars.title) - - -- Test that user functions work - assert.are.equal("Test Author", config.options.template_vars.author()) - assert.are.equal("test-project", config.options.template_vars.project()) - end) - - describe("workspaces", function() - it("sets up workspace with custom config", function() - local workspace_opts = { - vault_path = "/work/notes", - templates_path = "/work/templates" - } - - config.setup_workspace("work", workspace_opts) - - assert.is_not_nil(config.workspaces.work) - assert.are.equal("/work/notes", config.workspaces.work.vault_path) - assert.are.equal("/work/templates", config.workspaces.work.templates_path) - assert.is_not_nil(config.workspaces.work.dailies_path) -- Should inherit from defaults - end) - - it("merges workspace config with defaults", function() - local workspace_opts = { - vault_path = "/personal/notes" - } - - config.setup_workspace("personal", workspace_opts) - - assert.are.equal("/personal/notes", config.workspaces.personal.vault_path) - assert.is_not_nil(config.workspaces.personal.templates_path) - assert.is_not_nil(config.workspaces.personal.template_vars) - assert.is_not_nil(config.workspaces.personal.mappings) - end) - - it("returns workspace list", function() - config.setup_workspace("work", { vault_path = "/work" }) - config.setup_workspace("personal", { vault_path = "/personal" }) - - local workspaces = config.get_workspaces() - - assert.is_not_nil(workspaces.work) - assert.is_not_nil(workspaces.personal) - assert.are.equal("/work", workspaces.work.vault_path) - assert.are.equal("/personal", workspaces.personal.vault_path) - end) - end) - - describe("workspace detection", function() - before_each(function() - config.setup_workspace("work", { vault_path = "/work/notes" }) - config.setup_workspace("personal", { vault_path = "/personal/notes" }) - -- Set work as default to match expected behavior - config.set_default_workspace("work") - end) - - it("uses first workspace as active workspace", function() - -- With simplified system, first workspace configured becomes active - local workspace_config, workspace_name = config.get_current_config() - - -- "work" is set up first in before_each, so it becomes the active workspace - assert.are.equal("work", workspace_name) - assert.are.equal("/work/notes", workspace_config.vault_path) - end) - - - it("handles empty buffer name by using active workspace", function() - -- No need to mock buffer name - simplified system doesn't depend on it - local workspace_config, workspace_name = config.get_current_config() - - -- Should use the first workspace (work) that was set up in before_each - assert.are.equal("work", workspace_name) - assert.are.equal("/work/notes", workspace_config.vault_path) - end) - end) - - describe("default workspace", function() - before_each(function() - config.setup({ vault_path = "/fallback/notes" }) - config.setup_workspace("work", { vault_path = "/work/notes" }) - config.setup_workspace("personal", { vault_path = "/personal/notes" }) - end) - - it("sets and gets default workspace", function() - local success = config.set_default_workspace("work") - - assert.is_true(success) - assert.are.equal("work", config.get_default_workspace()) - end) - - it("fails to set non-existent workspace as default", function() - local success = config.set_default_workspace("nonexistent") - - assert.is_false(success) - assert.is_nil(config.get_default_workspace()) - end) - - it("sets default workspace from main config", function() - -- Reset state - config.options = {} - config.workspaces = {} - config.default_workspace = nil - config.current_active_workspace = nil - - -- Setup with default_workspace in config - config.setup({ - vault_path = "/base/notes", - default_workspace = "personal" - }) - config.setup_workspace("work", { vault_path = "/work/notes" }) - config.setup_workspace("personal", { vault_path = "/personal/notes" }) - - assert.are.equal("personal", config.get_default_workspace()) - - -- Should use personal workspace as active workspace - local workspace_config, workspace_name = config.get_current_config() - assert.are.equal("personal", workspace_name) - assert.are.equal("/personal/notes", workspace_config.vault_path) - end) - - it("first workspace becomes default when no default_workspace specified", function() - -- Reset state - config.options = {} - config.workspaces = {} - config.default_workspace = nil - config.current_active_workspace = nil - - -- Setup without default_workspace in config - config.setup({ vault_path = "/base/notes" }) - - -- First workspace should become default (via init.lua logic) - local init = require("markdown-notes.init") - init.setup_workspace("work", { vault_path = "/work/notes" }) - init.setup_workspace("personal", { vault_path = "/personal/notes" }) - - assert.are.equal("work", config.get_default_workspace()) - - -- Should use work workspace as active workspace - local workspace_config, workspace_name = config.get_current_config() - assert.are.equal("work", workspace_name) - assert.are.equal("/work/notes", workspace_config.vault_path) - end) - - it("uses default workspace for empty buffer paths", function() - config.set_default_workspace("personal") - - -- Mock vim.api.nvim_buf_get_name to return empty string - local original_get_name = vim.api.nvim_buf_get_name - vim.api.nvim_buf_get_name = function(bufnr) - return "" - end - - local workspace_config, workspace_name = config.get_current_config() - - assert.are.equal("personal", workspace_name) - assert.are.equal("/personal/notes", workspace_config.vault_path) - - -- Restore original function - vim.api.nvim_buf_get_name = original_get_name - end) - - it("uses default workspace when no path matches", function() - config.set_default_workspace("work") - - -- Mock vim.api.nvim_buf_get_name to return non-matching path - local original_get_name = vim.api.nvim_buf_get_name - vim.api.nvim_buf_get_name = function(bufnr) - return "/random/location/file.md" - end - - local workspace_config, workspace_name = config.get_current_config() - - assert.are.equal("work", workspace_name) - assert.are.equal("/work/notes", workspace_config.vault_path) - - -- Restore original function - vim.api.nvim_buf_get_name = original_get_name - end) - - - end) -end) \ No newline at end of file + before_each(function() + config.options = {} + config.workspaces = {} + config.default_workspace = nil + config.current_active_workspace = nil + end) + + it("has default configuration", function() + assert.is_not_nil(config.defaults) + assert.is_not_nil(config.defaults.vault_path) + assert.is_not_nil(config.defaults.templates_path) + assert.is_not_nil(config.defaults.template_vars) + assert.is_not_nil(config.defaults.mappings) + end) + + it("merges user options with defaults", function() + local user_opts = { + vault_path = "/custom/path", + custom_option = "test", + } + + config.setup(user_opts) + + assert.are.equal("/custom/path", config.options.vault_path) + assert.are.equal("test", config.options.custom_option) + assert.is_not_nil(config.options.templates_path) + end) + + it("merges user-defined template variables with defaults", function() + local user_opts = { + template_vars = { + author = function() + return "Test Author" + end, + project = function() + return "test-project" + end, + custom_string = "static-value", + }, + } + + config.setup(user_opts) + + -- User variables should be present + assert.is_function(config.options.template_vars.author) + assert.is_function(config.options.template_vars.project) + assert.are.equal("static-value", config.options.template_vars.custom_string) + + -- Default variables should still be present + assert.is_function(config.options.template_vars.date) + assert.is_function(config.options.template_vars.time) + assert.is_function(config.options.template_vars.title) + + -- Test that user functions work + assert.are.equal("Test Author", config.options.template_vars.author()) + assert.are.equal("test-project", config.options.template_vars.project()) + end) + + it("deep merges nested options", function() + local user_opts = { + mappings = { + daily_note_today = "dt", + }, + } + + config.setup(user_opts) + + assert.are.equal("dt", config.options.mappings.daily_note_today) + assert.is_not_nil(config.options.mappings.new_note) + end) + + describe("workspaces", function() + it("sets up workspace with custom config", function() + local workspace_opts = { + vault_path = "/work/notes", + templates_path = "/work/templates", + } + + config.setup_workspace("work", workspace_opts) + + assert.is_not_nil(config.workspaces.work) + assert.are.equal("/work/notes", config.workspaces.work.vault_path) + assert.are.equal("/work/templates", config.workspaces.work.templates_path) + assert.is_not_nil(config.workspaces.work.dailies_path) -- Should inherit from defaults + end) + + it("merges workspace config with defaults", function() + local workspace_opts = { + vault_path = "/personal/notes", + } + + config.setup_workspace("personal", workspace_opts) + + assert.are.equal("/personal/notes", config.workspaces.personal.vault_path) + assert.is_not_nil(config.workspaces.personal.templates_path) + assert.is_not_nil(config.workspaces.personal.template_vars) + assert.is_not_nil(config.workspaces.personal.mappings) + end) + + it("returns workspace list", function() + config.setup_workspace("work", { vault_path = "/work" }) + config.setup_workspace("personal", { vault_path = "/personal" }) + + local workspaces = config.get_workspaces() + + assert.is_not_nil(workspaces.work) + assert.is_not_nil(workspaces.personal) + assert.are.equal("/work", workspaces.work.vault_path) + assert.are.equal("/personal", workspaces.personal.vault_path) + end) + end) + + describe("workspace detection", function() + before_each(function() + config.setup_workspace("work", { vault_path = "/work/notes" }) + config.setup_workspace("personal", { vault_path = "/personal/notes" }) + -- Set work as default to match expected behavior + config.set_default_workspace("work") + end) + + it("uses first workspace as active workspace", function() + -- With simplified system, first workspace configured becomes active + local workspace_config, workspace_name = config.get_current_config() + + -- "work" is set up first in before_each, so it becomes the active workspace + assert.are.equal("work", workspace_name) + assert.are.equal("/work/notes", workspace_config.vault_path) + end) + + it("handles empty buffer name by using active workspace", function() + -- No need to mock buffer name - simplified system doesn't depend on it + local workspace_config, workspace_name = config.get_current_config() + + -- Should use the first workspace (work) that was set up in before_each + assert.are.equal("work", workspace_name) + assert.are.equal("/work/notes", workspace_config.vault_path) + end) + end) + + describe("default workspace", function() + before_each(function() + config.setup({ vault_path = "/fallback/notes" }) + config.setup_workspace("work", { vault_path = "/work/notes" }) + config.setup_workspace("personal", { vault_path = "/personal/notes" }) + end) + + it("sets and gets default workspace", function() + local success = config.set_default_workspace("work") + + assert.is_true(success) + assert.are.equal("work", config.get_default_workspace()) + end) + + it("fails to set non-existent workspace as default", function() + local success = config.set_default_workspace("nonexistent") + + assert.is_false(success) + assert.is_nil(config.get_default_workspace()) + end) + + it("sets default workspace from main config", function() + -- Reset state + config.options = {} + config.workspaces = {} + config.default_workspace = nil + config.current_active_workspace = nil + + -- Setup with default_workspace in config + config.setup({ + vault_path = "/base/notes", + default_workspace = "personal", + }) + config.setup_workspace("work", { vault_path = "/work/notes" }) + config.setup_workspace("personal", { vault_path = "/personal/notes" }) + + assert.are.equal("personal", config.get_default_workspace()) + + -- Should use personal workspace as active workspace + local workspace_config, workspace_name = config.get_current_config() + assert.are.equal("personal", workspace_name) + assert.are.equal("/personal/notes", workspace_config.vault_path) + end) + + it("first workspace becomes default when no default_workspace specified", function() + -- Reset state + config.options = {} + config.workspaces = {} + config.default_workspace = nil + config.current_active_workspace = nil + + -- Setup without default_workspace in config + config.setup({ vault_path = "/base/notes" }) + + -- First workspace should become default (via init.lua logic) + local init = require("markdown-notes.init") + init.setup_workspace("work", { vault_path = "/work/notes" }) + init.setup_workspace("personal", { vault_path = "/personal/notes" }) + + assert.are.equal("work", config.get_default_workspace()) + + -- Should use work workspace as active workspace + local workspace_config, workspace_name = config.get_current_config() + assert.are.equal("work", workspace_name) + assert.are.equal("/work/notes", workspace_config.vault_path) + end) + + it("uses default workspace for empty buffer paths", function() + config.set_default_workspace("personal") + + -- Mock vim.api.nvim_buf_get_name to return empty string + local original_get_name = vim.api.nvim_buf_get_name + vim.api.nvim_buf_get_name = function(bufnr) + return "" + end + + local workspace_config, workspace_name = config.get_current_config() + + assert.are.equal("personal", workspace_name) + assert.are.equal("/personal/notes", workspace_config.vault_path) + + -- Restore original function + vim.api.nvim_buf_get_name = original_get_name + end) + + it("uses default workspace when no path matches", function() + config.set_default_workspace("work") + + -- Mock vim.api.nvim_buf_get_name to return non-matching path + local original_get_name = vim.api.nvim_buf_get_name + vim.api.nvim_buf_get_name = function(bufnr) + return "/random/location/file.md" + end + + local workspace_config, workspace_name = config.get_current_config() + + assert.are.equal("work", workspace_name) + assert.are.equal("/work/notes", workspace_config.vault_path) + + -- Restore original function + vim.api.nvim_buf_get_name = original_get_name + end) + end) +end) diff --git a/tests/markdown-notes/links_spec.lua b/tests/markdown-notes/links_spec.lua index 9929af1..51f8272 100644 --- a/tests/markdown-notes/links_spec.lua +++ b/tests/markdown-notes/links_spec.lua @@ -2,402 +2,400 @@ local links = require("markdown-notes.links") local config = require("markdown-notes.config") describe("links", function() - local temp_dir = "/tmp/markdown-notes-test" - local vault_path = temp_dir .. "/vault" - - before_each(function() - -- Clean up and create test directory - vim.fn.system("rm -rf " .. temp_dir) - vim.fn.mkdir(vault_path, "p") - - -- Setup config - config.setup({ - vault_path = vault_path - }) - - -- Mock vim.fn.confirm to always return 1 (Yes) - _G.original_confirm = vim.fn.confirm - vim.fn.confirm = function(message, choices, default) - return 1 - end - - -- Mock vim.notify to capture notifications - _G.notifications = {} - _G.original_notify = vim.notify - vim.notify = function(message, level) - table.insert(_G.notifications, {message = message, level = level}) - end - end) - - after_each(function() - -- Restore original functions - vim.fn.confirm = _G.original_confirm - vim.notify = _G.original_notify - - -- Clean up - vim.fn.system("rm -rf " .. temp_dir) - end) - - describe("rename_note", function() - it("renames a note without links", function() - -- Create a test note - local note_path = vault_path .. "/test-note.md" - vim.fn.writefile({"# Test Note", "This is a test note"}, note_path) - - -- Open the note - vim.cmd("edit " .. note_path) - - -- Rename the note - links.rename_note("renamed-note") - - -- Check that the file was renamed - assert.is_true(vim.fn.filereadable(vault_path .. "/renamed-note.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - - -- Check notification - assert.is_true(#_G.notifications > 0) - assert.is_not_nil(_G.notifications[#_G.notifications].message:match("Renamed note")) - end) - - it("renames a note and updates simple links", function() - -- Create notes with links - local note_path = vault_path .. "/original-note.md" - local linking_note_path = vault_path .. "/linking-note.md" - - vim.fn.writefile({"# Original Note", "Content here"}, note_path) - vim.fn.writefile({"# Linking Note", "See [[original-note]] for details"}, linking_note_path) - - -- Verify initial state - local initial_content = table.concat(vim.fn.readfile(linking_note_path), "\n") - assert.is_not_nil(initial_content:find("[[original-note]]", 1, true)) - - -- Open the original note - vim.cmd("edit " .. note_path) - - -- Rename the note - links.rename_note("new-name") - - -- Check that the file was renamed - assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - - -- Check that the link was updated - local linking_content = vim.fn.readfile(linking_note_path) - local content_str = table.concat(linking_content, "\n") - - - assert.is_not_nil(content_str:find("[[new-name]]", 1, true)) - assert.is_nil(content_str:find("[[original-note]]", 1, true)) - - -- Check notification mentions updating files - assert.is_true(#_G.notifications > 0) - assert.is_not_nil(_G.notifications[#_G.notifications].message:match("updated 1 files")) - end) - - it("renames a note and updates display text links", function() - -- Create notes with display text links - local note_path = vault_path .. "/technical-doc.md" - local linking_note_path = vault_path .. "/index.md" - - vim.fn.writefile({"# Technical Documentation", "Content here"}, note_path) - vim.fn.writefile({"# Index", "Check out [[technical-doc|Technical Docs]] for info"}, linking_note_path) - - -- Open the original note - vim.cmd("edit " .. note_path) - - -- Rename the note - links.rename_note("tech-guide") - - -- Check that the file was renamed - assert.is_true(vim.fn.filereadable(vault_path .. "/tech-guide.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - - -- Check that the display text link was updated but display text preserved - local linking_content = vim.fn.readfile(linking_note_path) - local content_str = table.concat(linking_content, "\n") - assert.is_not_nil(content_str:find("[[tech-guide|Technical Docs]]", 1, true)) - assert.is_nil(content_str:find("[[technical-doc|Technical Docs]]", 1, true)) - end) - - it("handles multiple files with different link types", function() - -- Create the note to be renamed - local note_path = vault_path .. "/main-topic.md" - vim.fn.writefile({"# Main Topic", "Content here"}, note_path) - - -- Create multiple files with different link types - local file1_path = vault_path .. "/file1.md" - local file2_path = vault_path .. "/file2.md" - local file3_path = vault_path .. "/file3.md" - - vim.fn.writefile({"See [[main-topic]] for details"}, file1_path) - vim.fn.writefile({"Reference: [[main-topic|Main Topic Page]]"}, file2_path) - vim.fn.writefile({"Both [[main-topic]] and [[main-topic|the main topic]]"}, file3_path) - - -- Open the note to rename - vim.cmd("edit " .. note_path) - - -- Rename the note - links.rename_note("primary-topic") - - -- Check file was renamed - assert.is_true(vim.fn.filereadable(vault_path .. "/primary-topic.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - - -- Check all links were updated - local file1_content = table.concat(vim.fn.readfile(file1_path), "\n") - local file2_content = table.concat(vim.fn.readfile(file2_path), "\n") - local file3_content = table.concat(vim.fn.readfile(file3_path), "\n") - - assert.is_not_nil(file1_content:find("[[primary-topic]]", 1, true)) - assert.is_not_nil(file2_content:find("[[primary-topic|Main Topic Page]]", 1, true)) - assert.is_not_nil(file3_content:find("[[primary-topic]]", 1, true)) - assert.is_not_nil(file3_content:find("[[primary-topic|the main topic]]", 1, true)) - - -- Check notification mentions updating 3 files - assert.is_true(#_G.notifications > 0) - assert.is_not_nil(_G.notifications[#_G.notifications].message:match("updated 3 files")) - end) - - it("prevents overwriting existing files", function() - -- Create original note and target note - local note_path = vault_path .. "/original.md" - local existing_path = vault_path .. "/existing.md" - - vim.fn.writefile({"# Original"}, note_path) - vim.fn.writefile({"# Existing"}, existing_path) - - -- Open original note - vim.cmd("edit " .. note_path) - - -- Try to rename to existing file name - links.rename_note("existing") - - -- Check that original file was not renamed - assert.is_true(vim.fn.filereadable(note_path) == 1) - assert.is_true(vim.fn.filereadable(existing_path) == 1) - - -- Check error notification - assert.is_true(#_G.notifications > 0) - local found_error = false - for _, notification in ipairs(_G.notifications) do - if notification.message:match("File already exists") then - found_error = true - break - end - end - assert.is_true(found_error) - end) - - it("handles notes in subdirectories", function() - -- Create subdirectory and note - local subdir = vault_path .. "/projects" - vim.fn.mkdir(subdir, "p") - local note_path = subdir .. "/project-a.md" - local linking_note_path = vault_path .. "/index.md" - - vim.fn.writefile({"# Project A"}, note_path) - vim.fn.writefile({"See [[projects/project-a]] for details"}, linking_note_path) - - -- Open the note - vim.cmd("edit " .. note_path) - - -- Rename the note - links.rename_note("alpha-project") - - -- Check file was renamed in same directory - assert.is_true(vim.fn.filereadable(subdir .. "/alpha-project.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - - -- Check link was updated with correct path - local linking_content = table.concat(vim.fn.readfile(linking_note_path), "\n") - assert.is_not_nil(linking_content:find("[[projects/alpha-project]]", 1, true)) - assert.is_nil(linking_content:find("[[projects/project-a]]", 1, true)) - end) - - it("strips .md extension from new name", function() - -- Create a test note - local note_path = vault_path .. "/test.md" - vim.fn.writefile({"# Test"}, note_path) - - -- Open the note - vim.cmd("edit " .. note_path) - - -- Rename with .md extension - links.rename_note("new-name.md") - - -- Check that file was renamed without double extension - assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) - assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md.md") == 0) - end) - - it("handles similar note names without partial matches", function() - -- Create notes with similar names - local note_path = vault_path .. "/project.md" - local similar_note_path = vault_path .. "/project-archive.md" - local linking_note_path = vault_path .. "/index.md" - - vim.fn.writefile({"# Project"}, note_path) - vim.fn.writefile({"# Project Archive"}, similar_note_path) - vim.fn.writefile({ - "# Index", - "See [[project]] for current work", - "See [[project-archive]] for old work" - }, linking_note_path) - - -- Verify initial state - local initial_content = table.concat(vim.fn.readfile(linking_note_path), "\n") - assert.is_not_nil(initial_content:find("[[project]]", 1, true)) - assert.is_not_nil(initial_content:find("[[project-archive]]", 1, true)) - - -- Open and rename the "project" note - vim.cmd("edit " .. note_path) - links.rename_note("main-project") - - -- Check that files were renamed correctly - assert.is_true(vim.fn.filereadable(vault_path .. "/main-project.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - assert.is_true(vim.fn.filereadable(similar_note_path) == 1) -- Should still exist - - -- Check that links were updated correctly - local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") - - -- Should find the new link - assert.is_not_nil(final_content:find("[[main-project]]", 1, true)) - - -- Should NOT find the old exact link - assert.is_nil(final_content:find("[[project]]", 1, true)) - - -- Should still have the similar link UNCHANGED - assert.is_not_nil(final_content:find("[[project-archive]]", 1, true)) - - -- Verify the similar link wasn't corrupted - assert.is_nil(final_content:find("[[main-project-archive]]", 1, true)) - - print("Final content:", final_content) - end) - - it("handles very similar note names correctly", function() - -- Test even trickier edge cases - local note_path = vault_path .. "/api.md" - local linking_note_path = vault_path .. "/docs.md" - - vim.fn.writefile({"# API"}, note_path) - vim.fn.writefile({ - "Links: [[api]], [[api-docs]], [[api-v2]], [[legacy-api]]" - }, linking_note_path) - - -- Open and rename - vim.cmd("edit " .. note_path) - links.rename_note("new-api") - - -- Check final content - local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") - - -- Only the exact match should be replaced - assert.is_not_nil(final_content:find("[[new-api]]", 1, true)) - assert.is_not_nil(final_content:find("[[api-docs]]", 1, true)) - assert.is_not_nil(final_content:find("[[api-v2]]", 1, true)) - assert.is_not_nil(final_content:find("[[legacy-api]]", 1, true)) - - -- The old exact link should be gone - assert.is_nil(final_content:find("[[api]]", 1, true)) - - print("Very similar test result:", final_content) - end) - - it("handles files with spaces in names", function() - -- Create notes with spaces in filenames - local note_path = vault_path .. "/my project.md" - local linking_note_path = vault_path .. "/index.md" - - vim.fn.writefile({"# My Project"}, note_path) - vim.fn.writefile({"See [[my project]] for details"}, linking_note_path) - - -- Open and rename - vim.cmd("edit " .. vim.fn.fnameescape(note_path)) - links.rename_note("new project name") - - -- Check results - assert.is_true(vim.fn.filereadable(vault_path .. "/new project name.md") == 1) - assert.is_true(vim.fn.filereadable(note_path) == 0) - - local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") - assert.is_not_nil(final_content:find("[[new project name]]", 1, true)) - assert.is_nil(final_content:find("[[my project]]", 1, true)) - end) - - it("handles empty or whitespace-only names gracefully", function() - local note_path = vault_path .. "/test.md" - vim.fn.writefile({"# Test"}, note_path) - vim.cmd("edit " .. note_path) - - -- Clear notifications - _G.notifications = {} - - -- Test empty string - links.rename_note("") - assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist - - -- Test whitespace only - links.rename_note(" ") - assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist - - -- Should have error notifications - local found_error = false - for _, notification in ipairs(_G.notifications) do - if notification.level == vim.log.levels.ERROR then - found_error = true - break - end - end - assert.is_true(found_error) - end) - - it("handles invalid filename characters", function() - local note_path = vault_path .. "/test.md" - vim.fn.writefile({"# Test"}, note_path) - vim.cmd("edit " .. note_path) - - -- Clear notifications - _G.notifications = {} - - -- Test invalid characters - links.rename_note("test/invalid") - links.rename_note("test\\invalid") - links.rename_note("test:invalid") - - -- File should still exist since rename should fail - assert.is_true(vim.fn.filereadable(note_path) == 1) - - -- Should have error notifications - local found_error = false - for _, notification in ipairs(_G.notifications) do - if notification.level == vim.log.levels.ERROR and - notification.message:find("invalid characters") then - found_error = true - break - end - end - assert.is_true(found_error) - end) - - it("handles no current file gracefully", function() - -- Clear current buffer - vim.cmd("enew") - - -- Should handle gracefully without crashing - links.rename_note("test") - - -- Check for appropriate notification - assert.is_true(#_G.notifications > 0) - local found_warning = false - for _, notification in ipairs(_G.notifications) do - if notification.message:find("No current file") then - found_warning = true - break - end - end - assert.is_true(found_warning) - end) - end) -end) \ No newline at end of file + local temp_dir = "/tmp/markdown-notes-test" + local vault_path = temp_dir .. "/vault" + + before_each(function() + -- Clean up and create test directory + vim.fn.system("rm -rf " .. temp_dir) + vim.fn.mkdir(vault_path, "p") + + -- Setup config + config.setup({ + vault_path = vault_path, + }) + + -- Mock vim.fn.confirm to always return 1 (Yes) + _G.original_confirm = vim.fn.confirm + vim.fn.confirm = function(message, choices, default) + return 1 + end + + -- Mock vim.notify to capture notifications + _G.notifications = {} + _G.original_notify = vim.notify + vim.notify = function(message, level) + table.insert(_G.notifications, { message = message, level = level }) + end + end) + + after_each(function() + -- Restore original functions + vim.fn.confirm = _G.original_confirm + vim.notify = _G.original_notify + + -- Clean up + vim.fn.system("rm -rf " .. temp_dir) + end) + + describe("rename_note", function() + it("renames a note without links", function() + -- Create a test note + local note_path = vault_path .. "/test-note.md" + vim.fn.writefile({ "# Test Note", "This is a test note" }, note_path) + + -- Open the note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("renamed-note") + + -- Check that the file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/renamed-note.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check notification + assert.is_true(#_G.notifications > 0) + assert.is_not_nil(_G.notifications[#_G.notifications].message:match("Renamed note")) + end) + + it("renames a note and updates simple links", function() + -- Create notes with links + local note_path = vault_path .. "/original-note.md" + local linking_note_path = vault_path .. "/linking-note.md" + + vim.fn.writefile({ "# Original Note", "Content here" }, note_path) + vim.fn.writefile({ "# Linking Note", "See [[original-note]] for details" }, linking_note_path) + + -- Verify initial state + local initial_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(initial_content:find("[[original-note]]", 1, true)) + + -- Open the original note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("new-name") + + -- Check that the file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check that the link was updated + local linking_content = vim.fn.readfile(linking_note_path) + local content_str = table.concat(linking_content, "\n") + + assert.is_not_nil(content_str:find("[[new-name]]", 1, true)) + assert.is_nil(content_str:find("[[original-note]]", 1, true)) + + -- Check notification mentions updating files + assert.is_true(#_G.notifications > 0) + assert.is_not_nil(_G.notifications[#_G.notifications].message:match("updated 1 files")) + end) + + it("renames a note and updates display text links", function() + -- Create notes with display text links + local note_path = vault_path .. "/technical-doc.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({ "# Technical Documentation", "Content here" }, note_path) + vim.fn.writefile({ "# Index", "Check out [[technical-doc|Technical Docs]] for info" }, linking_note_path) + + -- Open the original note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("tech-guide") + + -- Check that the file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/tech-guide.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check that the display text link was updated but display text preserved + local linking_content = vim.fn.readfile(linking_note_path) + local content_str = table.concat(linking_content, "\n") + assert.is_not_nil(content_str:find("[[tech-guide|Technical Docs]]", 1, true)) + assert.is_nil(content_str:find("[[technical-doc|Technical Docs]]", 1, true)) + end) + + it("handles multiple files with different link types", function() + -- Create the note to be renamed + local note_path = vault_path .. "/main-topic.md" + vim.fn.writefile({ "# Main Topic", "Content here" }, note_path) + + -- Create multiple files with different link types + local file1_path = vault_path .. "/file1.md" + local file2_path = vault_path .. "/file2.md" + local file3_path = vault_path .. "/file3.md" + + vim.fn.writefile({ "See [[main-topic]] for details" }, file1_path) + vim.fn.writefile({ "Reference: [[main-topic|Main Topic Page]]" }, file2_path) + vim.fn.writefile({ "Both [[main-topic]] and [[main-topic|the main topic]]" }, file3_path) + + -- Open the note to rename + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("primary-topic") + + -- Check file was renamed + assert.is_true(vim.fn.filereadable(vault_path .. "/primary-topic.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check all links were updated + local file1_content = table.concat(vim.fn.readfile(file1_path), "\n") + local file2_content = table.concat(vim.fn.readfile(file2_path), "\n") + local file3_content = table.concat(vim.fn.readfile(file3_path), "\n") + + assert.is_not_nil(file1_content:find("[[primary-topic]]", 1, true)) + assert.is_not_nil(file2_content:find("[[primary-topic|Main Topic Page]]", 1, true)) + assert.is_not_nil(file3_content:find("[[primary-topic]]", 1, true)) + assert.is_not_nil(file3_content:find("[[primary-topic|the main topic]]", 1, true)) + + -- Check notification mentions updating 3 files + assert.is_true(#_G.notifications > 0) + assert.is_not_nil(_G.notifications[#_G.notifications].message:match("updated 3 files")) + end) + + it("prevents overwriting existing files", function() + -- Create original note and target note + local note_path = vault_path .. "/original.md" + local existing_path = vault_path .. "/existing.md" + + vim.fn.writefile({ "# Original" }, note_path) + vim.fn.writefile({ "# Existing" }, existing_path) + + -- Open original note + vim.cmd("edit " .. note_path) + + -- Try to rename to existing file name + links.rename_note("existing") + + -- Check that original file was not renamed + assert.is_true(vim.fn.filereadable(note_path) == 1) + assert.is_true(vim.fn.filereadable(existing_path) == 1) + + -- Check error notification + assert.is_true(#_G.notifications > 0) + local found_error = false + for _, notification in ipairs(_G.notifications) do + if notification.message:match("File already exists") then + found_error = true + break + end + end + assert.is_true(found_error) + end) + + it("handles notes in subdirectories", function() + -- Create subdirectory and note + local subdir = vault_path .. "/projects" + vim.fn.mkdir(subdir, "p") + local note_path = subdir .. "/project-a.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({ "# Project A" }, note_path) + vim.fn.writefile({ "See [[projects/project-a]] for details" }, linking_note_path) + + -- Open the note + vim.cmd("edit " .. note_path) + + -- Rename the note + links.rename_note("alpha-project") + + -- Check file was renamed in same directory + assert.is_true(vim.fn.filereadable(subdir .. "/alpha-project.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Check link was updated with correct path + local linking_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(linking_content:find("[[projects/alpha-project]]", 1, true)) + assert.is_nil(linking_content:find("[[projects/project-a]]", 1, true)) + end) + + it("strips .md extension from new name", function() + -- Create a test note + local note_path = vault_path .. "/test.md" + vim.fn.writefile({ "# Test" }, note_path) + + -- Open the note + vim.cmd("edit " .. note_path) + + -- Rename with .md extension + links.rename_note("new-name.md") + + -- Check that file was renamed without double extension + assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) + assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md.md") == 0) + end) + + it("handles similar note names without partial matches", function() + -- Create notes with similar names + local note_path = vault_path .. "/project.md" + local similar_note_path = vault_path .. "/project-archive.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({ "# Project" }, note_path) + vim.fn.writefile({ "# Project Archive" }, similar_note_path) + vim.fn.writefile({ + "# Index", + "See [[project]] for current work", + "See [[project-archive]] for old work", + }, linking_note_path) + + -- Verify initial state + local initial_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(initial_content:find("[[project]]", 1, true)) + assert.is_not_nil(initial_content:find("[[project-archive]]", 1, true)) + + -- Open and rename the "project" note + vim.cmd("edit " .. note_path) + links.rename_note("main-project") + + -- Check that files were renamed correctly + assert.is_true(vim.fn.filereadable(vault_path .. "/main-project.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + assert.is_true(vim.fn.filereadable(similar_note_path) == 1) -- Should still exist + + -- Check that links were updated correctly + local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + + -- Should find the new link + assert.is_not_nil(final_content:find("[[main-project]]", 1, true)) + + -- Should NOT find the old exact link + assert.is_nil(final_content:find("[[project]]", 1, true)) + + -- Should still have the similar link UNCHANGED + assert.is_not_nil(final_content:find("[[project-archive]]", 1, true)) + + -- Verify the similar link wasn't corrupted + assert.is_nil(final_content:find("[[main-project-archive]]", 1, true)) + + print("Final content:", final_content) + end) + + it("handles very similar note names correctly", function() + -- Test even trickier edge cases + local note_path = vault_path .. "/api.md" + local linking_note_path = vault_path .. "/docs.md" + + vim.fn.writefile({ "# API" }, note_path) + vim.fn.writefile({ + "Links: [[api]], [[api-docs]], [[api-v2]], [[legacy-api]]", + }, linking_note_path) + + -- Open and rename + vim.cmd("edit " .. note_path) + links.rename_note("new-api") + + -- Check final content + local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + + -- Only the exact match should be replaced + assert.is_not_nil(final_content:find("[[new-api]]", 1, true)) + assert.is_not_nil(final_content:find("[[api-docs]]", 1, true)) + assert.is_not_nil(final_content:find("[[api-v2]]", 1, true)) + assert.is_not_nil(final_content:find("[[legacy-api]]", 1, true)) + + -- The old exact link should be gone + assert.is_nil(final_content:find("[[api]]", 1, true)) + + print("Very similar test result:", final_content) + end) + + it("handles files with spaces in names", function() + -- Create notes with spaces in filenames + local note_path = vault_path .. "/my project.md" + local linking_note_path = vault_path .. "/index.md" + + vim.fn.writefile({ "# My Project" }, note_path) + vim.fn.writefile({ "See [[my project]] for details" }, linking_note_path) + + -- Open and rename + vim.cmd("edit " .. vim.fn.fnameescape(note_path)) + links.rename_note("new project name") + + -- Check results + assert.is_true(vim.fn.filereadable(vault_path .. "/new project name.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(final_content:find("[[new project name]]", 1, true)) + assert.is_nil(final_content:find("[[my project]]", 1, true)) + end) + + it("handles empty or whitespace-only names gracefully", function() + local note_path = vault_path .. "/test.md" + vim.fn.writefile({ "# Test" }, note_path) + vim.cmd("edit " .. note_path) + + -- Clear notifications + _G.notifications = {} + + -- Test empty string + links.rename_note("") + assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist + + -- Test whitespace only + links.rename_note(" ") + assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist + + -- Should have error notifications + local found_error = false + for _, notification in ipairs(_G.notifications) do + if notification.level == vim.log.levels.ERROR then + found_error = true + break + end + end + assert.is_true(found_error) + end) + + it("handles invalid filename characters", function() + local note_path = vault_path .. "/test.md" + vim.fn.writefile({ "# Test" }, note_path) + vim.cmd("edit " .. note_path) + + -- Clear notifications + _G.notifications = {} + + -- Test invalid characters + links.rename_note("test/invalid") + links.rename_note("test\\invalid") + links.rename_note("test:invalid") + + -- File should still exist since rename should fail + assert.is_true(vim.fn.filereadable(note_path) == 1) + + -- Should have error notifications + local found_error = false + for _, notification in ipairs(_G.notifications) do + if notification.level == vim.log.levels.ERROR and notification.message:find("invalid characters") then + found_error = true + break + end + end + assert.is_true(found_error) + end) + + it("handles no current file gracefully", function() + -- Clear current buffer + vim.cmd("enew") + + -- Should handle gracefully without crashing + links.rename_note("test") + + -- Check for appropriate notification + assert.is_true(#_G.notifications > 0) + local found_warning = false + for _, notification in ipairs(_G.notifications) do + if notification.message:find("No current file") then + found_warning = true + break + end + end + assert.is_true(found_warning) + end) + end) +end) diff --git a/tests/markdown-notes/notes_spec.lua b/tests/markdown-notes/notes_spec.lua index a422edc..6f3bc09 100644 --- a/tests/markdown-notes/notes_spec.lua +++ b/tests/markdown-notes/notes_spec.lua @@ -2,141 +2,151 @@ local notes = require("markdown-notes.notes") local config = require("markdown-notes.config") describe("notes", function() - before_each(function() - config.options = {} - config.workspaces = {} - config.setup({ - vault_path = "/tmp/test-vault", - notes_subdir = "notes" - }) - end) - - describe("create_new_note", function() - it("has create_new_note function", function() - assert.is_not_nil(notes.create_new_note) - assert.are.equal("function", type(notes.create_new_note)) - end) - - it("generates timestamp-based filename format", function() - -- Test the timestamp generation logic by checking it uses os.time - local original_time = os.time - local test_timestamp = 1720094400 - os.time = function() return test_timestamp end - - -- Mock vim.fn.input to return empty string (no title) - local original_input = vim.fn.input - vim.fn.input = function() return "" end - - -- Mock file operations to avoid actual file creation - local original_expand = vim.fn.expand - vim.fn.expand = function(path) - if path:match("^/tmp/test%-vault") then - return path - end - return original_expand(path) - end - - local original_fnamemodify = vim.fn.fnamemodify - vim.fn.fnamemodify = function(path, modifier) - if modifier == ":h" then - return "/tmp/test-vault/notes" - end - return original_fnamemodify(path, modifier) - end - - local original_isdirectory = vim.fn.isdirectory - vim.fn.isdirectory = function() return 1 end - - local opened_file = nil - local original_cmd = vim.cmd - vim.cmd = function(cmd) - if cmd:match("^edit ") then - opened_file = cmd:match("^edit (.+)$") - end - end - - local original_buf_set_lines = vim.api.nvim_buf_set_lines - vim.api.nvim_buf_set_lines = function() end - - -- Call the function - notes.create_new_note() - - -- Verify timestamp-based filename was used - assert.is_not_nil(opened_file) - assert.matches(tostring(test_timestamp), opened_file) - - -- Restore mocks - os.time = original_time - vim.fn.input = original_input - vim.fn.expand = original_expand - vim.fn.fnamemodify = original_fnamemodify - vim.fn.isdirectory = original_isdirectory - vim.cmd = original_cmd - vim.api.nvim_buf_set_lines = original_buf_set_lines - end) - end) - - describe("workspace integration", function() - it("uses workspace-specific vault path", function() - -- Set up workspace - config.setup_workspace("work", { - vault_path = "/work/notes", - notes_subdir = "projects" - }) - - -- Mock vim.api.nvim_buf_get_name to return work workspace path - local original_get_name = vim.api.nvim_buf_get_name - vim.api.nvim_buf_get_name = function(bufnr) - return "/work/notes/existing.md" - end - - -- Mock other functions - local original_input = vim.fn.input - vim.fn.input = function() return "test-note" end - - local original_expand = vim.fn.expand - vim.fn.expand = function(path) - return path - end - - local original_fnamemodify = vim.fn.fnamemodify - vim.fn.fnamemodify = function(path, modifier) - if modifier == ":h" then - return "/work/notes/projects" - end - return path - end - - local original_isdirectory = vim.fn.isdirectory - vim.fn.isdirectory = function() return 1 end - - local opened_file = nil - local original_cmd = vim.cmd - vim.cmd = function(cmd) - if cmd:match("^edit ") then - opened_file = cmd:match("^edit (.+)$") - end - end - - local original_buf_set_lines = vim.api.nvim_buf_set_lines - vim.api.nvim_buf_set_lines = function() end - - -- Call the function - notes.create_new_note() - - -- Verify workspace-specific path was used - assert.is_not_nil(opened_file) - assert.matches("/work/notes/projects", opened_file) - assert.matches("test%-note", opened_file) - - -- Restore mocks - vim.api.nvim_buf_get_name = original_get_name - vim.fn.input = original_input - vim.fn.expand = original_expand - vim.fn.fnamemodify = original_fnamemodify - vim.fn.isdirectory = original_isdirectory - vim.cmd = original_cmd - vim.api.nvim_buf_set_lines = original_buf_set_lines - end) - end) -end) \ No newline at end of file + before_each(function() + config.options = {} + config.workspaces = {} + config.setup({ + vault_path = "/tmp/test-vault", + notes_subdir = "notes", + }) + end) + + describe("create_new_note", function() + it("has create_new_note function", function() + assert.is_not_nil(notes.create_new_note) + assert.are.equal("function", type(notes.create_new_note)) + end) + + it("generates timestamp-based filename format", function() + -- Test the timestamp generation logic by checking it uses os.time + local original_os = _G.os + local test_timestamp = 1720094400 + _G.os = setmetatable({ + time = function() return test_timestamp end + }, { __index = original_os }) + + -- Mock vim.fn.input to return empty string (no title) + local original_input = vim.fn.input + vim.fn.input = function() + return "" + end + + -- Mock file operations to avoid actual file creation + local original_expand = vim.fn.expand + vim.fn.expand = function(path) + if path:match("^/tmp/test%-vault") then + return path + end + return original_expand(path) + end + + local original_fnamemodify = vim.fn.fnamemodify + vim.fn.fnamemodify = function(path, modifier) + if modifier == ":h" then + return "/tmp/test-vault/notes" + end + return original_fnamemodify(path, modifier) + end + + local original_isdirectory = vim.fn.isdirectory + vim.fn.isdirectory = function() + return 1 + end + + local opened_file = nil + local original_cmd = vim.cmd + vim.cmd = function(cmd) + if cmd:match("^edit ") then + opened_file = cmd:match("^edit (.+)$") + end + end + + local original_buf_set_lines = vim.api.nvim_buf_set_lines + vim.api.nvim_buf_set_lines = function() end + + -- Call the function + notes.create_new_note() + + -- Verify timestamp-based filename was used + assert.is_not_nil(opened_file) + assert.matches(tostring(test_timestamp), opened_file) + + -- Restore mocks + _G.os = original_os + vim.fn.input = original_input + vim.fn.expand = original_expand + vim.fn.fnamemodify = original_fnamemodify + vim.fn.isdirectory = original_isdirectory + vim.cmd = original_cmd + vim.api.nvim_buf_set_lines = original_buf_set_lines + end) + end) + + describe("workspace integration", function() + it("uses workspace-specific vault path", function() + -- Set up workspace + config.setup_workspace("work", { + vault_path = "/work/notes", + notes_subdir = "projects", + }) + + -- Mock vim.api.nvim_buf_get_name to return work workspace path + local original_get_name = vim.api.nvim_buf_get_name + vim.api.nvim_buf_get_name = function(bufnr) + return "/work/notes/existing.md" + end + + -- Mock other functions + local original_input = vim.fn.input + vim.fn.input = function() + return "test-note" + end + + local original_expand = vim.fn.expand + vim.fn.expand = function(path) + return path + end + + local original_fnamemodify = vim.fn.fnamemodify + vim.fn.fnamemodify = function(path, modifier) + if modifier == ":h" then + return "/work/notes/projects" + end + return path + end + + local original_isdirectory = vim.fn.isdirectory + vim.fn.isdirectory = function() + return 1 + end + + local opened_file = nil + local original_cmd = vim.cmd + vim.cmd = function(cmd) + if cmd:match("^edit ") then + opened_file = cmd:match("^edit (.+)$") + end + end + + local original_buf_set_lines = vim.api.nvim_buf_set_lines + vim.api.nvim_buf_set_lines = function() end + + -- Call the function + notes.create_new_note() + + -- Verify workspace-specific path was used + assert.is_not_nil(opened_file) + assert.matches("/work/notes/projects", opened_file) + assert.matches("test%-note", opened_file) + + -- Restore mocks + vim.api.nvim_buf_get_name = original_get_name + vim.fn.input = original_input + vim.fn.expand = original_expand + vim.fn.fnamemodify = original_fnamemodify + vim.fn.isdirectory = original_isdirectory + vim.cmd = original_cmd + vim.api.nvim_buf_set_lines = original_buf_set_lines + end) + end) +end) diff --git a/tests/markdown-notes/templates_spec.lua b/tests/markdown-notes/templates_spec.lua index fd0b013..3381b0f 100644 --- a/tests/markdown-notes/templates_spec.lua +++ b/tests/markdown-notes/templates_spec.lua @@ -2,94 +2,106 @@ local templates = require("markdown-notes.templates") local config = require("markdown-notes.config") describe("templates", function() - before_each(function() - config.options = {} - config.workspaces = {} - config.setup({}) - end) - - describe("substitute_template_vars", function() - it("substitutes date variables", function() - local content = {"Today is {{date}}", "Time is {{time}}"} - local result = templates.substitute_template_vars(content) - - assert.is_not.equal("Today is {{date}}", result[1]) - assert.is_not.equal("Time is {{time}}", result[2]) - assert.matches("%d%d%d%d%-%d%d%-%d%d", result[1]) - assert.matches("%d%d:%d%d", result[2]) - end) - - it("substitutes custom variables", function() - local content = {"Hello {{name}}"} - local custom_vars = {name = "World"} - local result = templates.substitute_template_vars(content, custom_vars) - - assert.are.equal("Hello World", result[1]) - end) - - it("handles function variables", function() - local content = {"Value is {{custom}}"} - local custom_vars = {custom = function() return "dynamic" end} - local result = templates.substitute_template_vars(content, custom_vars) - - assert.are.equal("Value is dynamic", result[1]) - end) - - it("handles multiple substitutions in one line", function() - local content = {"{{date}} - {{time}} - {{title}}"} - local result = templates.substitute_template_vars(content) - - assert.matches("%d%d%d%d%-%d%d%-%d%d", result[1]) - assert.matches("%d%d:%d%d", result[1]) - end) - - it("uses config-defined template variables", function() - -- Setup config with custom template variables - config.setup({ - template_vars = { - author = function() return "Test Author" end, - project = function() return "my-project" end, - custom_static = "static-content" - } - }) - - local content = { - "Author: {{author}}", - "Project: {{project}}", - "Static: {{custom_static}}", - "Date: {{date}}" - } - - local result = templates.substitute_template_vars(content) - - -- Custom variables should be substituted - assert.are.equal("Author: Test Author", result[1]) - assert.are.equal("Project: my-project", result[2]) - assert.are.equal("Static: static-content", result[3]) - - -- Default variables should still work - assert.matches("Date: %d%d%d%d%-%d%d%-%d%d", result[4]) - end) - - it("overrides config variables with custom vars parameter", function() - -- Setup config with a template variable - config.setup({ - template_vars = { - author = function() return "Config Author" end, - } - }) - - local content = {"Author: {{author}}"} - - -- Override with custom vars - local custom_vars = { - author = function() return "Override Author" end - } - - local result = templates.substitute_template_vars(content, custom_vars) - - -- Should use the override, not the config value - assert.are.equal("Author: Override Author", result[1]) - end) - end) -end) \ No newline at end of file + before_each(function() + config.options = {} + config.workspaces = {} + config.setup({}) + end) + + describe("substitute_template_vars", function() + it("substitutes date variables", function() + local content = { "Today is {{date}}", "Time is {{time}}" } + local result = templates.substitute_template_vars(content) + + assert.is_not.equal("Today is {{date}}", result[1]) + assert.is_not.equal("Time is {{time}}", result[2]) + assert.matches("%d%d%d%d%-%d%d%-%d%d", result[1]) + assert.matches("%d%d:%d%d", result[2]) + end) + + it("substitutes custom variables", function() + local content = { "Hello {{name}}" } + local custom_vars = { name = "World" } + local result = templates.substitute_template_vars(content, custom_vars) + + assert.are.equal("Hello World", result[1]) + end) + + it("handles function variables", function() + local content = { "Value is {{custom}}" } + local custom_vars = { + custom = function() + return "dynamic" + end, + } + local result = templates.substitute_template_vars(content, custom_vars) + + assert.are.equal("Value is dynamic", result[1]) + end) + + it("handles multiple substitutions in one line", function() + local content = { "{{date}} - {{time}} - {{title}}" } + local result = templates.substitute_template_vars(content) + + assert.matches("%d%d%d%d%-%d%d%-%d%d", result[1]) + assert.matches("%d%d:%d%d", result[1]) + end) + + it("uses config-defined template variables", function() + -- Setup config with custom template variables + config.setup({ + template_vars = { + author = function() + return "Test Author" + end, + project = function() + return "my-project" + end, + custom_static = "static-content", + }, + }) + + local content = { + "Author: {{author}}", + "Project: {{project}}", + "Static: {{custom_static}}", + "Date: {{date}}", + } + + local result = templates.substitute_template_vars(content) + + -- Custom variables should be substituted + assert.are.equal("Author: Test Author", result[1]) + assert.are.equal("Project: my-project", result[2]) + assert.are.equal("Static: static-content", result[3]) + + -- Default variables should still work + assert.matches("Date: %d%d%d%d%-%d%d%-%d%d", result[4]) + end) + + it("overrides config variables with custom vars parameter", function() + -- Setup config with a template variable + config.setup({ + template_vars = { + author = function() + return "Config Author" + end, + }, + }) + + local content = { "Author: {{author}}" } + + -- Override with custom vars + local custom_vars = { + author = function() + return "Override Author" + end, + } + + local result = templates.substitute_template_vars(content, custom_vars) + + -- Should use the override, not the config value + assert.are.equal("Author: Override Author", result[1]) + end) + end) +end) diff --git a/tests/markdown-notes/workspace_spec.lua b/tests/markdown-notes/workspace_spec.lua index 2c5feae..ec91c62 100644 --- a/tests/markdown-notes/workspace_spec.lua +++ b/tests/markdown-notes/workspace_spec.lua @@ -1,63 +1,61 @@ local config = require("markdown-notes.config") describe("workspace", function() - before_each(function() - config.options = {} - config.workspaces = {} - config.default_workspace = nil - end) - - describe("workspace configuration", function() - it("sets up workspace correctly", function() - config.setup_workspace("work", { vault_path = "/work/notes" }) - - local workspaces = config.get_workspaces() - assert.is_not_nil(workspaces.work) - assert.are.equal("/work/notes", workspaces.work.vault_path) - end) - - it("sets up multiple workspaces", function() - config.setup_workspace("work", { vault_path = "/work/notes" }) - config.setup_workspace("personal", { vault_path = "/personal/notes" }) - - local workspaces = config.get_workspaces() - assert.is_not_nil(workspaces.work) - assert.is_not_nil(workspaces.personal) - assert.are.equal("/work/notes", workspaces.work.vault_path) - assert.are.equal("/personal/notes", workspaces.personal.vault_path) - end) - - it("workspace inherits from defaults", function() - config.setup_workspace("test", { vault_path = "/test" }) - - local workspaces = config.get_workspaces() - local test_workspace = workspaces.test - - assert.are.equal("/test", test_workspace.vault_path) - assert.is_not_nil(test_workspace.templates_path) - assert.is_not_nil(test_workspace.template_vars) - assert.is_not_nil(test_workspace.mappings) - end) - end) - - describe("workspace detection", function() - before_each(function() - config.setup({ vault_path = "/default/notes" }) - config.setup_workspace("work", { vault_path = "/work/notes" }) - config.setup_workspace("personal", { vault_path = "/personal/notes" }) - -- Set work as default to match expected behavior - config.set_default_workspace("work") - end) - - it("uses first workspace as active workspace", function() - -- With simplified system, first workspace configured becomes active - local workspace_config, workspace_name = config.get_current_config() - - -- "work" is set up first in before_each, so it becomes the active workspace - assert.are.equal("work", workspace_name) - assert.are.equal("/work/notes", workspace_config.vault_path) - end) - - - end) -end) \ No newline at end of file + before_each(function() + config.options = {} + config.workspaces = {} + config.default_workspace = nil + end) + + describe("workspace configuration", function() + it("sets up workspace correctly", function() + config.setup_workspace("work", { vault_path = "/work/notes" }) + + local workspaces = config.get_workspaces() + assert.is_not_nil(workspaces.work) + assert.are.equal("/work/notes", workspaces.work.vault_path) + end) + + it("sets up multiple workspaces", function() + config.setup_workspace("work", { vault_path = "/work/notes" }) + config.setup_workspace("personal", { vault_path = "/personal/notes" }) + + local workspaces = config.get_workspaces() + assert.is_not_nil(workspaces.work) + assert.is_not_nil(workspaces.personal) + assert.are.equal("/work/notes", workspaces.work.vault_path) + assert.are.equal("/personal/notes", workspaces.personal.vault_path) + end) + + it("workspace inherits from defaults", function() + config.setup_workspace("test", { vault_path = "/test" }) + + local workspaces = config.get_workspaces() + local test_workspace = workspaces.test + + assert.are.equal("/test", test_workspace.vault_path) + assert.is_not_nil(test_workspace.templates_path) + assert.is_not_nil(test_workspace.template_vars) + assert.is_not_nil(test_workspace.mappings) + end) + end) + + describe("workspace detection", function() + before_each(function() + config.setup({ vault_path = "/default/notes" }) + config.setup_workspace("work", { vault_path = "/work/notes" }) + config.setup_workspace("personal", { vault_path = "/personal/notes" }) + -- Set work as default to match expected behavior + config.set_default_workspace("work") + end) + + it("uses first workspace as active workspace", function() + -- With simplified system, first workspace configured becomes active + local workspace_config, workspace_name = config.get_current_config() + + -- "work" is set up first in before_each, so it becomes the active workspace + assert.are.equal("work", workspace_name) + assert.are.equal("/work/notes", workspace_config.vault_path) + end) + end) +end) diff --git a/tests/minimal_init.vim b/tests/minimal_init.vim index bf4f596..ff7a088 100644 --- a/tests/minimal_init.vim +++ b/tests/minimal_init.vim @@ -2,4 +2,4 @@ set rtp+=. set rtp+=~/.local/share/nvim/site/pack/vendor/start/plenary.nvim set rtp+=~/.local/share/nvim/site/pack/vendor/start/fzf-lua -runtime plugin/plenary.vim \ No newline at end of file +runtime plugin/plenary.vim From 2471dd59e0bd47dbc912525da56391120ec11455 Mon Sep 17 00:00:00 2001 From: Jason Paris Date: Mon, 7 Jul 2025 11:10:40 -0400 Subject: [PATCH 7/7] feat: enhance rename function with fzf-lua file preview - Add fzf-lua preview interface showing files that will be updated during rename - New ui.show_rename_preview config option (default: true) to control behavior - Maintain backward compatibility with skip_ui option for tests - Fix buffer management issue where both old and new file buffers remained open - Remove redundant confirmation dialog after preview for better UX - Update all documentation (README, help files) with new functionality - Add comprehensive test coverage for config option and buffer handling - Clean up debug statements and fix linting issues - Improve luacheck configuration for better code formatting Users can now see exactly which files will be affected before confirming a rename operation, with proper buffer management and the ability to preview file contents. The preview can be disabled if desired. --- .luacheckrc | 48 ++++++++------- README.md | 17 +++++- doc/markdown-notes.txt | 31 ++++++++-- doc/tags | 1 + lua/markdown-notes/config.lua | 6 ++ lua/markdown-notes/links.lua | 91 ++++++++++++++++++++++++----- tests/markdown-notes/links_spec.lua | 75 +++++++++++++++++------- tests/markdown-notes/notes_spec.lua | 4 +- 8 files changed, 209 insertions(+), 64 deletions(-) diff --git a/.luacheckrc b/.luacheckrc index 5ce58f4..7cdc317 100644 --- a/.luacheckrc +++ b/.luacheckrc @@ -5,41 +5,49 @@ std = "luajit" -- Add Neovim globals globals = { - "vim", + "vim", } -- Additional read-only globals for testing read_globals = { - -- Busted testing framework - "describe", "it", "before_each", "after_each", "setup", "teardown", - "assert", "spy", "stub", "mock", - -- Plenary testing - "require", + -- Busted testing framework + "describe", + "it", + "before_each", + "after_each", + "setup", + "teardown", + "assert", + "spy", + "stub", + "mock", + -- Plenary testing + "require", } -- Files/directories to exclude exclude_files = { - ".luarocks/", - "doc/tags", + ".luarocks/", + "doc/tags", } -- Ignore specific warnings ignore = { - "212", -- Unused argument (common in Neovim plugins for callback functions) - "213", -- Unused loop variable (common in ipairs/pairs loops) + "212", -- Unused argument (common in Neovim plugins for callback functions) + "213", -- Unused loop variable (common in ipairs/pairs loops) } -- Maximum line length -max_line_length = 100 +max_line_length = 120 -- Files and their specific configurations files = { - ["tests/"] = { - -- Allow longer lines in tests for readability - max_line_length = 120, - -- Additional testing globals - globals = { - "vim", -- vim is mocked in tests - } - } -} \ No newline at end of file + ["tests/"] = { + -- Allow longer lines in tests for readability + max_line_length = 120, + -- Additional testing globals + globals = { + "vim", -- vim is mocked in tests + }, + }, +} diff --git a/README.md b/README.md index ec3934d..bdce8c2 100644 --- a/README.md +++ b/README.md @@ -53,7 +53,7 @@ That's it! You're ready to start building your knowledge base. - **📅 Daily Notes** - Quick creation and navigation with automatic templating - **📝 Template System** - Flexible templates with variable substitution (`{{date}}`, `{{time}}`, `{{title}}`, etc.) - **🔗 Wiki-style Links** - Create and follow `[[note-name]]` links between notes -- **🔄 Smart Renaming** - Rename notes and automatically update all references +- **🔄 Smart Renaming** - Rename notes and automatically update all references with file preview - **🔍 Powerful Search** - Find notes by filename or content with syntax highlighting - **↩ī¸ Backlinks** - Discover which notes reference the current note @@ -136,7 +136,7 @@ All keybindings use `n` as the prefix for easy discovery: | `np` | Insert template | Insert template at cursor | | `ng` | Search tags | Find notes by frontmatter tags | | `nb` | Show backlinks | Show notes linking to current note | -| `nr` | Rename note | Rename note and update all references | +| `nr` | Rename note | Rename note and update all references with preview | | `nw` | Pick workspace | Switch between workspaces | | `gf` | Follow link | Follow link under cursor | @@ -185,6 +185,14 @@ gf → Follow the link under cursor nr → Rename current note and update all references ``` +**Smart Renaming**: When you rename a note that has links pointing to it, markdown-notes.nvim will: +1. Show you a preview of all files that will be updated +2. Let you browse through them with fzf-lua +3. Update all `[[note-name]]` and `[[note-name|display text]]` references automatically +4. Handle files in subdirectories correctly + +> **💡 Tip:** You can disable the preview and use a simple confirmation dialog by setting `ui.show_rename_preview = false` in your configuration. + ### Using Templates Templates make your notes consistent and save time: @@ -239,6 +247,11 @@ require("markdown-notes").setup({ -- Template settings default_template = "basic", -- Auto-apply this template to new notes + -- UI behavior + ui = { + show_rename_preview = true, -- Show file preview when renaming notes with links + }, + -- Custom template variables template_vars = { date = function() return os.date("%Y-%m-%d") end, diff --git a/doc/markdown-notes.txt b/doc/markdown-notes.txt index 3e7a9a3..85c2274 100644 --- a/doc/markdown-notes.txt +++ b/doc/markdown-notes.txt @@ -33,7 +33,7 @@ Core Features~ - Daily Notes - Quick creation and navigation with automatic templating - Template System - Flexible templates with variable substitution - Wiki-style Links - Create and follow [[note-name]] links between notes -- Smart Renaming - Rename notes and automatically update all references +- Smart Renaming - Rename notes and automatically update all references with file preview - Powerful Search - Find notes by filename or content with syntax highlighting - Backlinks - Discover which notes reference the current note @@ -158,9 +158,20 @@ Creating Links Between Notes: > Following and Managing Links: > gf → Follow the link under cursor nb → Show all notes that link to current note (backlinks) - nr → Rename current note and update all references + nr → Rename current note and update all references with preview < +Smart Renaming~ + *markdown-notes-usage-smart-renaming* +When you rename a note that has links pointing to it, markdown-notes.nvim will: +1. Show you a preview of all files that will be updated +2. Let you browse through them with fzf-lua and file preview +3. Update all `[[note-name]]` and `[[note-name|display text]]` references +4. Handle files in subdirectories correctly + +You can disable the preview and use a simple confirmation dialog by setting +`ui.show_rename_preview = false` in your configuration. + Using Templates~ *markdown-notes-usage-templates* Templates make your notes consistent and save time: > @@ -206,7 +217,7 @@ Note Management~ Links and Navigation~ `nl` Search for note and insert wiki-link `nb` Show notes linking to current note -`nr` Rename note and update all references +`nr` Rename note and update all references with preview `gf` Follow link under cursor Templates and Tags~ @@ -235,6 +246,11 @@ Custom Configuration Options~ -- Template settings default_template = "basic", -- Auto-apply this template to new notes + -- UI behavior + ui = { + show_rename_preview = true, -- Show file preview when renaming notes with links + }, + -- Custom template variables template_vars = { date = function() return os.date("%Y-%m-%d") end, @@ -416,7 +432,8 @@ Ex Commands~ *markdown-notes-ex-commands* :MarkdownNotesRename [{name}] *:MarkdownNotesRename* Rename current note and update all references. If {name} is not provided, - prompts for the new name. Shows confirmation dialog with file count. + prompts for the new name. Shows file preview with affected files or + confirmation dialog depending on configuration. Function API~ *markdown-notes-function-commands* @@ -452,10 +469,12 @@ require("markdown-notes.links").follow_link() *markdown-notes.follow_link* require("markdown-notes.links").show_backlinks() *markdown-notes.show_backlinks* Show backlinks to the current note. -require("markdown-notes.links").rename_note(new_name) *markdown-notes.rename_note* +require("markdown-notes.links").rename_note(new_name, opts) *markdown-notes.rename_note* Rename the current note and automatically update all wiki-style link references across the vault. Supports both `[[note]]` and `[[note|display]]` - formats. Shows confirmation dialog with file count before proceeding. + formats. Shows file preview with affected files by default, or simple + confirmation if ui.show_rename_preview is false. Optional {opts} table + accepts skip_ui boolean for programmatic usage. require("markdown-notes.templates").pick_template() *markdown-notes.pick_template* Pick and insert a template at cursor position. diff --git a/doc/tags b/doc/tags index 0559b3d..f4dcbed 100644 --- a/doc/tags +++ b/doc/tags @@ -29,6 +29,7 @@ markdown-notes-usage-daily-notes markdown-notes.txt /*markdown-notes-usage-daily markdown-notes-usage-guide markdown-notes.txt /*markdown-notes-usage-guide* markdown-notes-usage-links markdown-notes.txt /*markdown-notes-usage-links* markdown-notes-usage-note-management markdown-notes.txt /*markdown-notes-usage-note-management* +markdown-notes-usage-smart-renaming markdown-notes.txt /*markdown-notes-usage-smart-renaming* markdown-notes-usage-templates markdown-notes.txt /*markdown-notes-usage-templates* markdown-notes-workspace-commands markdown-notes.txt /*markdown-notes-workspace-commands* markdown-notes-workspace-setup markdown-notes.txt /*markdown-notes-workspace-setup* diff --git a/lua/markdown-notes/config.lua b/lua/markdown-notes/config.lua index 817122f..824f199 100644 --- a/lua/markdown-notes/config.lua +++ b/lua/markdown-notes/config.lua @@ -33,6 +33,12 @@ M.defaults = { -- Default workspace (optional) default_workspace = nil, + -- UI behavior + ui = { + -- Show file preview when renaming notes that have links + show_rename_preview = true, + }, + -- Key mappings mappings = { daily_note_today = "nd", diff --git a/lua/markdown-notes/links.lua b/lua/markdown-notes/links.lua index 458f2e9..64fbb78 100644 --- a/lua/markdown-notes/links.lua +++ b/lua/markdown-notes/links.lua @@ -110,8 +110,7 @@ function M.show_backlinks() local search_text = "[[" .. relative_path .. "]]" -- Get all markdown files first, then check each one - local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. - " && find . -name '*.md' -type f -not -path '*/.*'" + local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*'" local all_files = vim.fn.systemlist(all_files_cmd) -- Remove ./ prefix from paths @@ -162,7 +161,8 @@ function M.show_backlinks() }) end -function M.rename_note(new_name) +function M.rename_note(new_name, opts) + opts = opts or {} local current_path = vim.fn.expand("%:p") local options = config.get_current_config() local vault_path = vim.fn.expand(options.vault_path) @@ -211,8 +211,7 @@ function M.rename_note(new_name) local link_with_display = "%[%[" .. vim.pesc(relative_path) .. "|" -- Get all markdown files - local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. - " && find . -name '*.md' -type f -not -path '*/.*'" + local all_files_cmd = "cd " .. vim.fn.shellescape(vault_path) .. " && find . -name '*.md' -type f -not -path '*/.*'" local all_files = vim.fn.systemlist(all_files_cmd) -- Remove ./ prefix from paths @@ -256,18 +255,65 @@ function M.rename_note(new_name) new_relative_path = current_dir_relative .. "/" .. new_name end - -- Ask for confirmation - local message = "Rename '" .. relative_path .. "' to '" .. new_name .. "'" - if #files_to_update > 0 then - message = message .. " and update " .. #files_to_update .. " files with links?" + -- Show affected files and ask for confirmation + if #files_to_update > 0 and not opts.skip_ui and options.ui.show_rename_preview then + local ok, fzf = pcall(require, "fzf-lua") + if not ok then + vim.notify("fzf-lua not available", vim.log.levels.ERROR) + return + end + + -- Show files that will be updated + local file_list = {} + for _, file_info in ipairs(files_to_update) do + table.insert(file_list, file_info.file) + end + + fzf.fzf_exec(file_list, { + prompt = "Files to update (" .. #files_to_update .. ") - Enter to rename, Esc to cancel > ", + cwd = vault_path, + previewer = "builtin", + actions = { + ["default"] = function() + -- Proceed with rename directly (preview was the confirmation) + M._perform_rename( + current_path, + new_file_path, + files_to_update, + relative_path, + new_relative_path, + update_count + ) + end, + }, + }) else - message = message .. "?" + -- Skip UI for tests or when no files to update + local message = "Rename '" .. relative_path .. "' to '" .. new_name .. "'" + if #files_to_update > 0 then + message = message .. " and update " .. #files_to_update .. " files?" + else + message = message .. "?" + end + local confirm = opts.skip_ui and 1 or vim.fn.confirm(message, "&Yes\n&No", 2) + if confirm == 1 then + M._perform_rename( + current_path, + new_file_path, + files_to_update, + relative_path, + new_relative_path, + update_count + ) + end end +end - local confirm = vim.fn.confirm(message, "&Yes\n&No", 2) - if confirm ~= 1 then - return - end +-- Helper function to perform the actual rename operation +function M._perform_rename(current_path, new_file_path, files_to_update, relative_path, new_relative_path, update_count) + -- Check if we're renaming the current buffer's file (before renaming) + local current_bufnr = vim.fn.bufnr("%") + local is_current_buffer = current_bufnr ~= -1 and vim.fn.expand("%:p") == current_path -- Update all linking files for _, file_info in ipairs(files_to_update) do @@ -293,7 +339,22 @@ function M.rename_note(new_name) -- Rename the actual file local success = vim.fn.rename(current_path, new_file_path) if success == 0 then - vim.cmd("edit " .. vim.fn.fnameescape(new_file_path)) + -- Handle buffer management if we renamed the current buffer's file + if is_current_buffer then + -- Update the buffer's filename to the new path + -- Use pcall to handle E95 error if buffer name already exists + local success_rename = pcall(vim.api.nvim_buf_set_name, current_bufnr, new_file_path) + if not success_rename then + -- If buffer name collision, force close conflicting buffer and retry + local conflicting_bufnr = vim.fn.bufnr(new_file_path) + if conflicting_bufnr ~= -1 then + vim.cmd("bwipeout! " .. conflicting_bufnr) + vim.api.nvim_buf_set_name(current_bufnr, new_file_path) + end + end + -- Reload the buffer to reflect the new filename + vim.cmd("edit!") + end if update_count > 0 then vim.notify("Renamed note and updated " .. update_count .. " files", vim.log.levels.INFO) else diff --git a/tests/markdown-notes/links_spec.lua b/tests/markdown-notes/links_spec.lua index 51f8272..de1f9b7 100644 --- a/tests/markdown-notes/links_spec.lua +++ b/tests/markdown-notes/links_spec.lua @@ -48,7 +48,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Rename the note - links.rename_note("renamed-note") + links.rename_note("renamed-note", { skip_ui = true }) -- Check that the file was renamed assert.is_true(vim.fn.filereadable(vault_path .. "/renamed-note.md") == 1) @@ -75,7 +75,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Rename the note - links.rename_note("new-name") + links.rename_note("new-name", { skip_ui = true }) -- Check that the file was renamed assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) @@ -105,7 +105,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Rename the note - links.rename_note("tech-guide") + links.rename_note("tech-guide", { skip_ui = true }) -- Check that the file was renamed assert.is_true(vim.fn.filereadable(vault_path .. "/tech-guide.md") == 1) @@ -136,7 +136,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Rename the note - links.rename_note("primary-topic") + links.rename_note("primary-topic", { skip_ui = true }) -- Check file was renamed assert.is_true(vim.fn.filereadable(vault_path .. "/primary-topic.md") == 1) @@ -169,7 +169,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Try to rename to existing file name - links.rename_note("existing") + links.rename_note("existing", { skip_ui = true }) -- Check that original file was not renamed assert.is_true(vim.fn.filereadable(note_path) == 1) @@ -201,7 +201,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Rename the note - links.rename_note("alpha-project") + links.rename_note("alpha-project", { skip_ui = true }) -- Check file was renamed in same directory assert.is_true(vim.fn.filereadable(subdir .. "/alpha-project.md") == 1) @@ -222,7 +222,7 @@ describe("links", function() vim.cmd("edit " .. note_path) -- Rename with .md extension - links.rename_note("new-name.md") + links.rename_note("new-name.md", { skip_ui = true }) -- Check that file was renamed without double extension assert.is_true(vim.fn.filereadable(vault_path .. "/new-name.md") == 1) @@ -250,7 +250,7 @@ describe("links", function() -- Open and rename the "project" note vim.cmd("edit " .. note_path) - links.rename_note("main-project") + links.rename_note("main-project", { skip_ui = true }) -- Check that files were renamed correctly assert.is_true(vim.fn.filereadable(vault_path .. "/main-project.md") == 1) @@ -271,8 +271,6 @@ describe("links", function() -- Verify the similar link wasn't corrupted assert.is_nil(final_content:find("[[main-project-archive]]", 1, true)) - - print("Final content:", final_content) end) it("handles very similar note names correctly", function() @@ -287,7 +285,7 @@ describe("links", function() -- Open and rename vim.cmd("edit " .. note_path) - links.rename_note("new-api") + links.rename_note("new-api", { skip_ui = true }) -- Check final content local final_content = table.concat(vim.fn.readfile(linking_note_path), "\n") @@ -300,8 +298,6 @@ describe("links", function() -- The old exact link should be gone assert.is_nil(final_content:find("[[api]]", 1, true)) - - print("Very similar test result:", final_content) end) it("handles files with spaces in names", function() @@ -314,7 +310,7 @@ describe("links", function() -- Open and rename vim.cmd("edit " .. vim.fn.fnameescape(note_path)) - links.rename_note("new project name") + links.rename_note("new project name", { skip_ui = true }) -- Check results assert.is_true(vim.fn.filereadable(vault_path .. "/new project name.md") == 1) @@ -334,11 +330,11 @@ describe("links", function() _G.notifications = {} -- Test empty string - links.rename_note("") + links.rename_note("", { skip_ui = true }) assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist -- Test whitespace only - links.rename_note(" ") + links.rename_note(" ", { skip_ui = true }) assert.is_true(vim.fn.filereadable(note_path) == 1) -- Should still exist -- Should have error notifications @@ -361,9 +357,9 @@ describe("links", function() _G.notifications = {} -- Test invalid characters - links.rename_note("test/invalid") - links.rename_note("test\\invalid") - links.rename_note("test:invalid") + links.rename_note("test/invalid", { skip_ui = true }) + links.rename_note("test\\invalid", { skip_ui = true }) + links.rename_note("test:invalid", { skip_ui = true }) -- File should still exist since rename should fail assert.is_true(vim.fn.filereadable(note_path) == 1) @@ -384,7 +380,7 @@ describe("links", function() vim.cmd("enew") -- Should handle gracefully without crashing - links.rename_note("test") + links.rename_note("test", { skip_ui = true }) -- Check for appropriate notification assert.is_true(#_G.notifications > 0) @@ -397,5 +393,44 @@ describe("links", function() end assert.is_true(found_warning) end) + + it("respects show_rename_preview config option", function() + -- Create a note with links + local note_path = vault_path .. "/original-note.md" + local linking_note_path = vault_path .. "/linking-note.md" + + vim.fn.writefile({ "# Original Note" }, note_path) + vim.fn.writefile({ "Link to [[original-note]]" }, linking_note_path) + + -- Test with show_rename_preview = false + local original_config = config.get_current_config() + local test_config = vim.deepcopy(original_config) + test_config.ui = test_config.ui or {} + test_config.ui.show_rename_preview = false + + -- Mock the config to return our test config + local original_get_config = config.get_current_config + config.get_current_config = function() + return test_config + end + + vim.cmd("edit " .. note_path) + + -- This should use simple confirmation, not fzf-lua preview + -- Since we're using skip_ui=true, it should still work + links.rename_note("renamed-note", { skip_ui = true }) + + -- Verify the rename worked + assert.is_true(vim.fn.filereadable(vault_path .. "/renamed-note.md") == 1) + assert.is_true(vim.fn.filereadable(note_path) == 0) + + -- Verify the link was updated + local updated_content = table.concat(vim.fn.readfile(linking_note_path), "\n") + assert.is_not_nil(updated_content:find("[[renamed-note]]", 1, true)) + assert.is_nil(updated_content:find("[[original-note]]", 1, true)) + + -- Restore original config + config.get_current_config = original_get_config + end) end) end) diff --git a/tests/markdown-notes/notes_spec.lua b/tests/markdown-notes/notes_spec.lua index 6f3bc09..738b5f0 100644 --- a/tests/markdown-notes/notes_spec.lua +++ b/tests/markdown-notes/notes_spec.lua @@ -22,7 +22,9 @@ describe("notes", function() local original_os = _G.os local test_timestamp = 1720094400 _G.os = setmetatable({ - time = function() return test_timestamp end + time = function() + return test_timestamp + end, }, { __index = original_os }) -- Mock vim.fn.input to return empty string (no title)