mirror of
https://github.com/Ascyii/telekasten.nvim.git
synced 2026-01-01 06:14:23 -05:00
3181 lines
101 KiB
Lua
3181 lines
101 KiB
Lua
local builtin = require("telescope.builtin")
|
|
local actions = require("telescope.actions")
|
|
local action_state = require("telescope.actions.state")
|
|
local action_set = require("telescope.actions.set")
|
|
local pickers = require("telescope.pickers")
|
|
local finders = require("telescope.finders")
|
|
local conf = require("telescope.config").values
|
|
local scan = require("plenary.scandir")
|
|
local utils = require("telescope.utils")
|
|
local previewers = require("telescope.previewers")
|
|
local make_entry = require("telescope.make_entry")
|
|
local entry_display = require("telescope.pickers.entry_display")
|
|
local sorters = require("telescope.sorters")
|
|
local themes = require("telescope.themes")
|
|
local debug_utils = require("plenary.debug_utils")
|
|
local filetype = require("plenary.filetype")
|
|
local taglinks = require("taglinks.taglinks")
|
|
local tagutils = require("taglinks.tagutils")
|
|
local linkutils = require("taglinks.linkutils")
|
|
local dateutils = require("taglinks.dateutils")
|
|
local Path = require("plenary.path")
|
|
local vaultPicker = require("vaultpicker")
|
|
local tkutils = require("telekasten.utils")
|
|
|
|
-- declare locals for the nvim api stuff to avoid more lsp warnings
|
|
local vim = vim
|
|
|
|
-- ----------------------------------------------------------------------------
|
|
-- DEFAULT CONFIG
|
|
-- ----------------------------------------------------------------------------
|
|
local _home = vim.fn.expand("~/zettelkasten")
|
|
local M = {}
|
|
local function defaultConfig(home)
|
|
if home == nil then
|
|
home = _home
|
|
end
|
|
|
|
local cfg = {
|
|
home = home,
|
|
|
|
-- if true, telekasten will be enabled when opening a note within the configured home
|
|
take_over_my_home = true,
|
|
|
|
-- auto-set telekasten filetype: if false, the telekasten filetype will not be used
|
|
-- and thus the telekasten syntax will not be loaded either
|
|
auto_set_filetype = true,
|
|
|
|
-- auto-set telekasten syntax: if false, the telekasten syntax will not be set
|
|
-- this syntax setting is independent from auto-set filetype
|
|
auto_set_syntax = true,
|
|
|
|
-- dir names for special notes (absolute path or subdir name)
|
|
dailies = home .. "/" .. "daily",
|
|
weeklies = home .. "/" .. "weekly",
|
|
templates = home .. "/" .. "templates",
|
|
|
|
-- image (sub)dir for pasting
|
|
-- dir name (absolute path or subdir name)
|
|
-- or nil if pasted images shouldn't go into a special subdir
|
|
image_subdir = nil,
|
|
|
|
-- markdown file extension
|
|
extension = ".md",
|
|
|
|
-- Generate note filenames. One of:
|
|
-- "title" (default) - Use title if supplied, uuid otherwise
|
|
-- "uuid" - Use uuid
|
|
-- "uuid-title" - Prefix title by uuid
|
|
-- "title-uuid" - Suffix title with uuid
|
|
new_note_filename = "title",
|
|
|
|
--[[ file UUID type
|
|
- "rand"
|
|
- string input for os.date()
|
|
- or custom lua function that returns a string
|
|
--]]
|
|
uuid_type = "%Y%m%d%H%M",
|
|
-- UUID separator
|
|
uuid_sep = "-",
|
|
|
|
-- if not nil, replaces any spaces in the title when it is used in filename generation
|
|
filename_space_subst = nil,
|
|
|
|
-- following a link to a non-existing note will create it
|
|
follow_creates_nonexisting = true,
|
|
dailies_create_nonexisting = true,
|
|
weeklies_create_nonexisting = true,
|
|
|
|
-- skip telescope prompt for goto_today and goto_thisweek
|
|
journal_auto_open = false,
|
|
|
|
-- templates for new notes
|
|
-- template_new_note = home .. "/" .. "templates/new_note.md",
|
|
-- template_new_daily = home .. "/" .. "templates/daily_tk.md",
|
|
-- template_new_weekly = home .. "/" .. "templates/weekly_tk.md",
|
|
|
|
-- image link style
|
|
-- wiki: ![[image name]]
|
|
-- markdown: 
|
|
image_link_style = "markdown",
|
|
|
|
-- default sort option: 'filename', 'modified'
|
|
sort = "filename",
|
|
|
|
-- when linking to a note in subdir/, create a [[subdir/title]] link
|
|
-- instead of a [[title only]] link
|
|
subdirs_in_links = true,
|
|
|
|
-- integrate with calendar-vim
|
|
plug_into_calendar = true,
|
|
calendar_opts = {
|
|
-- calendar week display mode: 1 .. 'WK01', 2 .. 'WK 1', 3 .. 'KW01', 4 .. 'KW 1', 5 .. '1'
|
|
weeknm = 4,
|
|
-- use monday as first day of week: 1 .. true, 0 .. false
|
|
calendar_monday = 1,
|
|
-- calendar mark: where to put mark for marked days: 'left', 'right', 'left-fit'
|
|
calendar_mark = "left-fit",
|
|
},
|
|
close_after_yanking = false,
|
|
insert_after_inserting = true,
|
|
|
|
-- tag notation: '#tag', ':tag:', 'yaml-bare'
|
|
tag_notation = "#tag",
|
|
|
|
-- command palette theme: dropdown (window) or ivy (bottom panel)
|
|
command_palette_theme = "ivy",
|
|
|
|
-- tag list theme:
|
|
-- get_cursor: small tag list at cursor; ivy and dropdown like above
|
|
show_tags_theme = "ivy",
|
|
|
|
-- template_handling
|
|
-- What to do when creating a new note via `new_note()` or `follow_link()`
|
|
-- to a non-existing note
|
|
-- - prefer_new_note: use `new_note` template
|
|
-- - smart: if day or week is detected in title, use daily / weekly templates (default)
|
|
-- - always_ask: always ask before creating a note
|
|
template_handling = "smart",
|
|
|
|
-- path handling:
|
|
-- this applies to:
|
|
-- - new_note()
|
|
-- - new_templated_note()
|
|
-- - follow_link() to non-existing note
|
|
--
|
|
-- it does NOT apply to:
|
|
-- - goto_today()
|
|
-- - goto_thisweek()
|
|
--
|
|
-- Valid options:
|
|
-- - smart: put daily-looking notes in daily, weekly-looking ones in weekly,
|
|
-- all other ones in home, except for notes/with/subdirs/in/title.
|
|
-- (default)
|
|
--
|
|
-- - prefer_home: put all notes in home except for goto_today(), goto_thisweek()
|
|
-- except for notes/with/subdirs/in/title.
|
|
--
|
|
-- - same_as_current: put all new notes in the dir of the current note if
|
|
-- present or else in home
|
|
-- except for notes/with/subdirs/in/title.
|
|
new_note_location = "smart",
|
|
|
|
-- should all links be updated when a file is renamed
|
|
rename_update_links = true,
|
|
|
|
-- how to preview media files
|
|
-- "telescope-media-files" if you have telescope-media-files.nvim installed
|
|
-- "catimg-previewer" if you have catimg installed
|
|
-- "viu-previewer" if you have viu installed
|
|
media_previewer = "telescope-media-files",
|
|
|
|
-- A customizable fallback handler for urls.
|
|
follow_url_fallback = nil,
|
|
}
|
|
M.Cfg = cfg
|
|
M.note_type_templates = {
|
|
normal = M.Cfg.template_new_note,
|
|
daily = M.Cfg.template_new_daily,
|
|
weekly = M.Cfg.template_new_weekly,
|
|
}
|
|
end
|
|
|
|
--- escapes a string for use as exact pattern within gsub
|
|
local function escape(s)
|
|
return string.gsub(s, "[%%%]%^%-$().[*+?]", "%%%1")
|
|
end
|
|
|
|
local function remove_alias(link)
|
|
local split_index = string.find(link, "%s*|")
|
|
if split_index ~= nil and type(split_index) == "number" then
|
|
return string.sub(link, 0, split_index - 1)
|
|
end
|
|
return link
|
|
end
|
|
|
|
local function file_exists(fname)
|
|
if fname == nil then
|
|
return false
|
|
end
|
|
|
|
local f = io.open(fname, "r")
|
|
if f ~= nil then
|
|
io.close(f)
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
local function random_variable(length)
|
|
math.randomseed(os.clock() ^ 5)
|
|
local res = ""
|
|
for _ = 1, length do
|
|
res = res .. string.char(math.random(97, 122))
|
|
end
|
|
return res
|
|
end
|
|
|
|
local function get_uuid(opts)
|
|
opts.uuid_type = opts.uuid_type or M.Cfg.uuid_type
|
|
|
|
local uuid
|
|
if opts.uuid_type == "rand" then
|
|
uuid = random_variable(6)
|
|
elseif type(opts.uuid_type) == "function" then
|
|
uuid = opts.uuid_type()
|
|
else
|
|
uuid = os.date(opts.uuid_type)
|
|
end
|
|
return uuid
|
|
end
|
|
|
|
local function generate_note_filename(uuid, title)
|
|
if M.Cfg.filename_space_subst ~= nil then
|
|
title = title:gsub(" ", M.Cfg.filename_space_subst)
|
|
end
|
|
|
|
local pp = Path:new(title)
|
|
local p_splits = pp:_split()
|
|
local filename = p_splits[#p_splits]
|
|
local subdir = title:gsub(escape(filename), "")
|
|
|
|
local sep = M.Cfg.uuid_sep or "-"
|
|
if M.Cfg.new_note_filename ~= "uuid" and #title > 0 then
|
|
if M.Cfg.new_note_filename == "uuid-title" then
|
|
return subdir .. uuid .. sep .. filename
|
|
elseif M.Cfg.new_note_filename == "title-uuid" then
|
|
return title .. sep .. uuid
|
|
else
|
|
return title
|
|
end
|
|
else
|
|
return uuid
|
|
end
|
|
end
|
|
|
|
local function print_error(s)
|
|
vim.cmd("echohl ErrorMsg")
|
|
vim.cmd("echomsg " .. '"' .. s .. '"')
|
|
vim.cmd("echohl None")
|
|
end
|
|
|
|
local function check_dir_and_ask(dir, purpose)
|
|
local ret = false
|
|
if dir ~= nil and Path:new(dir):exists() == false then
|
|
vim.ui.select({ "No (default)", "Yes" }, {
|
|
prompt = "Telekasten.nvim: "
|
|
.. purpose
|
|
.. " folder "
|
|
.. dir
|
|
.. " does not exist!"
|
|
.. " Shall I create it? ",
|
|
}, function(answer)
|
|
if answer == "Yes" then
|
|
if Path:new(dir):mkdir({ exists_ok = false }) then
|
|
vim.cmd('echomsg " "')
|
|
vim.cmd('echomsg "' .. dir .. ' created"')
|
|
ret = true
|
|
else
|
|
-- unreachable: plenary.Path:mkdir() will error out
|
|
print_error("Could not create directory " .. dir)
|
|
ret = false
|
|
end
|
|
end
|
|
end)
|
|
else
|
|
ret = true
|
|
end
|
|
return ret
|
|
end
|
|
|
|
local function global_dir_check()
|
|
local ret
|
|
if M.Cfg.home == nil then
|
|
print_error("Telekasten.nvim: home is not configured!")
|
|
ret = false
|
|
else
|
|
ret = check_dir_and_ask(M.Cfg.home, "home")
|
|
end
|
|
|
|
ret = ret and check_dir_and_ask(M.Cfg.dailies, "dailies")
|
|
ret = ret and check_dir_and_ask(M.Cfg.weeklies, "weeklies")
|
|
ret = ret and check_dir_and_ask(M.Cfg.templates, "templates")
|
|
ret = ret and check_dir_and_ask(M.Cfg.image_subdir, "images")
|
|
|
|
return ret
|
|
end
|
|
|
|
local function make_config_path_absolute(path)
|
|
local ret = path
|
|
if not (Path:new(path):is_absolute()) and path ~= nil then
|
|
ret = M.Cfg.home .. "/" .. path
|
|
end
|
|
return ret
|
|
end
|
|
|
|
-- sanitize strings
|
|
local escape_chars = function(string)
|
|
return string.gsub(string, "[%(|%)|\\|%[|%]|%-|%{%}|%?|%+|%*|%^|%$|%/]", {
|
|
["\\"] = "\\\\",
|
|
["-"] = "\\-",
|
|
["("] = "\\(",
|
|
[")"] = "\\)",
|
|
["["] = "\\[",
|
|
["]"] = "\\]",
|
|
["{"] = "\\{",
|
|
["}"] = "\\}",
|
|
["?"] = "\\?",
|
|
["+"] = "\\+",
|
|
["*"] = "\\*",
|
|
["^"] = "\\^",
|
|
["$"] = "\\$",
|
|
})
|
|
end
|
|
|
|
local function recursive_substitution(dir, old, new)
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
if vim.fn.executable("sed") == 0 then
|
|
vim.api.nvim_err_write("Sed not installed!\n")
|
|
return
|
|
end
|
|
|
|
old = escape_chars(old)
|
|
new = escape_chars(new)
|
|
|
|
local sedcommand = "sed -i"
|
|
if vim.fn.has("mac") == 1 then
|
|
sedcommand = "sed -i ''"
|
|
end
|
|
|
|
local replace_cmd = "rg -0 -l -t markdown '"
|
|
.. old
|
|
.. "' "
|
|
.. dir
|
|
.. " | xargs -0 "
|
|
.. sedcommand
|
|
.. " 's|"
|
|
.. old
|
|
.. "|"
|
|
.. new
|
|
.. "|g' >/dev/null 2>&1"
|
|
os.execute(replace_cmd)
|
|
end
|
|
|
|
local function save_all_mod_buffers()
|
|
for i = 1, vim.fn.bufnr("$") do
|
|
if
|
|
vim.fn.getbufvar(i, "&mod") == 1
|
|
and (
|
|
(
|
|
M.Cfg.auto_set_filetype == true
|
|
and vim.fn.getbufvar(i, "&filetype") == "telekasten"
|
|
)
|
|
or M.Cfg.auto_set_filetype == false
|
|
)
|
|
then
|
|
vim.cmd(i .. "bufdo w")
|
|
end
|
|
end
|
|
end
|
|
|
|
-- ----------------------------------------------------------------------------
|
|
-- image stuff
|
|
-- ----------------------------------------------------------------------------
|
|
|
|
local function make_relative_path(bufferpath, imagepath, sep)
|
|
sep = sep or "/"
|
|
|
|
-- Split the buffer and image path into their dirs/files
|
|
local buffer_dirs = {}
|
|
for w in string.gmatch(bufferpath, "([^" .. sep .. "]+)") do
|
|
buffer_dirs[#buffer_dirs + 1] = w
|
|
end
|
|
local image_dirs = {}
|
|
for w in string.gmatch(imagepath, "([^" .. sep .. "]+)") do
|
|
image_dirs[#image_dirs + 1] = w
|
|
end
|
|
|
|
-- The parts of the dir list that match won't matter, so skip them
|
|
local i = 1
|
|
while i < #image_dirs and i < #buffer_dirs do
|
|
if image_dirs[i] ~= buffer_dirs[i] then
|
|
break
|
|
else
|
|
i = i + 1
|
|
end
|
|
end
|
|
|
|
-- Append ../ to walk up from the buffer location and the path downward
|
|
-- to the location of the image file in order to create a relative path
|
|
local relative_path = ""
|
|
while i <= #image_dirs or i <= #buffer_dirs do
|
|
if i <= #image_dirs then
|
|
if relative_path == "" then
|
|
relative_path = image_dirs[i]
|
|
else
|
|
relative_path = relative_path .. sep .. image_dirs[i]
|
|
end
|
|
end
|
|
if i <= #buffer_dirs - 1 then
|
|
relative_path = ".." .. sep .. relative_path
|
|
end
|
|
i = i + 1
|
|
end
|
|
|
|
return relative_path
|
|
end
|
|
|
|
local function imgFromClipboard()
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local get_paste_command
|
|
if vim.fn.executable("xclip") == 1 then
|
|
get_paste_command = function(dir, filename)
|
|
return "xclip -selection clipboard -t image/png -o > "
|
|
.. dir
|
|
.. "/"
|
|
.. filename
|
|
end
|
|
elseif vim.fn.executable("wl-paste") == 1 then
|
|
get_paste_command = function(dir, filename)
|
|
return "wl-paste -n -t image/png > " .. dir .. "/" .. filename
|
|
end
|
|
elseif vim.fn.executable("osascript") == 1 then
|
|
get_paste_command = function(dir, filename)
|
|
return string.format(
|
|
'osascript -e "tell application \\"System Events\\" to write (the clipboard as «class PNGf») to '
|
|
.. '(make new file at folder \\"%s\\" with properties {name:\\"%s\\"})"',
|
|
dir,
|
|
filename
|
|
)
|
|
end
|
|
else
|
|
vim.api.nvim_err_write("No xclip installed!\n")
|
|
return
|
|
end
|
|
|
|
-- TODO: check `xclip -selection clipboard -t TARGETS -o` for the occurence of `image/png`
|
|
|
|
-- using plenary.job::new():sync() with on_stdout(_, data) unfortunately did some weird ASCII translation on the
|
|
-- data, so the PNGs were invalid. It seems like 0d 0a and single 0a bytes were stripped by the plenary job:
|
|
--
|
|
-- plenary job version:
|
|
-- $ hexdump -C /tmp/x.png|head
|
|
-- 00000000 89 50 4e 47 1a 00 00 00 49 48 44 52 00 00 03 19 |.PNG....IHDR....|
|
|
-- 00000010 00 00 01 c1 08 02 00 00 00 8a 73 e1 c3 00 00 00 |..........s.....|
|
|
-- 00000020 09 70 48 59 73 00 00 0e c4 00 00 0e c4 01 95 2b |.pHYs..........+|
|
|
-- 00000030 0e 1b 00 00 20 00 49 44 41 54 78 9c ec dd 77 58 |.... .IDATx...wX|
|
|
-- 00000040 14 d7 fa 07 f0 33 bb b3 4b af 0b 2c 08 22 1d 04 |.....3..K..,."..|
|
|
-- 00000050 05 11 10 1b a2 54 c5 1e bb b1 c6 98 c4 68 72 4d |.....T.......hrM|
|
|
-- 00000060 e2 cd 35 37 26 b9 49 6e 6e 7e f7 a6 98 98 a8 29 |..57&.Inn~.....)|
|
|
-- 00000070 26 6a 8c 51 63 8b bd 00 8a 58 40 b0 81 08 2a 45 |&j.Qc....X@...*E|
|
|
-- 00000080 69 52 17 58 ca ee b2 f5 f7 c7 ea 4a 10 66 d7 01 |iR.X.......J.f..|
|
|
-- 00000090 b1 e4 fb 79 7c f2 2c e7 cc 39 e7 3d 67 66 b3 2f |...y|.,..9.=gf./|
|
|
--
|
|
-- OK version
|
|
-- $ hexdump -C /tmp/x2.png|head
|
|
-- 00000000 89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 |.PNG........IHDR|
|
|
-- 00000010 00 00 03 19 00 00 01 c1 08 02 00 00 00 8a 73 e1 |..............s.|
|
|
-- 00000020 c3 00 00 00 09 70 48 59 73 00 00 0e c4 00 00 0e |.....pHYs.......|
|
|
-- 00000030 c4 01 95 2b 0e 1b 00 00 20 00 49 44 41 54 78 9c |...+.... .IDATx.|
|
|
-- 00000040 ec dd 77 58 14 d7 fa 07 f0 33 bb b3 4b af 0b 2c |..wX.....3..K..,|
|
|
-- 00000050 08 22 1d 04 05 11 10 1b a2 54 c5 1e bb b1 c6 98 |.".......T......|
|
|
-- 00000060 c4 68 72 4d e2 cd 35 37 26 b9 49 6e 6e 7e f7 a6 |.hrM..57&.Inn~..|
|
|
-- 00000070 98 98 a8 29 26 6a 8c 51 63 8b bd 00 8a 58 40 b0 |...)&j.Qc....X@.|
|
|
-- 00000080 81 08 2a 45 69 52 17 58 ca ee b2 f5 f7 c7 ea 4a |..*EiR.X.......J|
|
|
-- 00000090 10 66 d7 01 b1 e4 fb 79 7c f2 2c e7 cc 39 e7 3d |.f.....y|.,..9.=|
|
|
|
|
local pngname = "pasted_img_" .. os.date("%Y%m%d%H%M%S") .. ".png"
|
|
local pngdir = M.Cfg.image_subdir and M.Cfg.image_subdir or M.Cfg.home
|
|
local png = pngdir .. "/" .. pngname
|
|
local relpath = make_relative_path(vim.fn.expand("%:p"), png, "/")
|
|
|
|
local result = os.execute(get_paste_command(pngdir, pngname))
|
|
if result > 0 then
|
|
vim.api.nvim_err_writeln(
|
|
string.format(
|
|
"Unable to write image %s (exit code: %d). Is there an image on the clipboard? ",
|
|
png,
|
|
result
|
|
)
|
|
)
|
|
return
|
|
end
|
|
|
|
if file_exists(png) then
|
|
if M.Cfg.image_link_style == "markdown" then
|
|
vim.api.nvim_put({ "![](" .. relpath .. ")" }, "", true, true)
|
|
else
|
|
vim.api.nvim_put({ "![[" .. pngname .. "]]" }, "", true, true)
|
|
end
|
|
else
|
|
vim.api.nvim_err_writeln("Unable to write image " .. png)
|
|
end
|
|
end
|
|
|
|
-- end of image stuff
|
|
|
|
local function daysuffix(day)
|
|
day = tostring(day)
|
|
if (day == "1") or (day == "21") or (day == "31") then
|
|
return "st"
|
|
end
|
|
if (day == "2") or (day == "22") then
|
|
return "nd"
|
|
end
|
|
if (day == "3") or (day == "23") then
|
|
return "rd"
|
|
end
|
|
return "th"
|
|
end
|
|
|
|
local daymap = {
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday",
|
|
"Sunday",
|
|
}
|
|
local monthmap = {
|
|
"January",
|
|
"February",
|
|
"March",
|
|
"April",
|
|
"May",
|
|
"June",
|
|
"July",
|
|
"August",
|
|
"September",
|
|
"October",
|
|
"November",
|
|
"December",
|
|
}
|
|
|
|
local dateformats = {
|
|
date = "%Y-%m-%d",
|
|
week = "%V",
|
|
isoweek = "%Y-W%V",
|
|
time24 = "%H:%M:%S",
|
|
time12 = "%I:%M:%S %p",
|
|
}
|
|
|
|
local function calculate_dates(date)
|
|
local time = os.time(date)
|
|
local dinfo = os.date("*t", time) -- this normalizes the input to a full date table
|
|
local oneday = 24 * 60 * 60 -- hours * days * seconds
|
|
local oneweek = 7 * oneday
|
|
local df = dateformats
|
|
|
|
local dates = {}
|
|
|
|
-- this is to compensate for the calendar showing M-Su, but os.date Su is
|
|
-- always wday = 1
|
|
local wday = dinfo.wday - 1
|
|
if wday == 0 then
|
|
wday = 7
|
|
end
|
|
|
|
dates.year = dinfo.year
|
|
dates.month = dinfo.month
|
|
dates.day = dinfo.day
|
|
dates.hdate = daymap[wday]
|
|
.. ", "
|
|
.. monthmap[dinfo.month]
|
|
.. " "
|
|
.. dinfo.day
|
|
.. daysuffix(dinfo.day)
|
|
.. ", "
|
|
.. dinfo.year
|
|
|
|
local zonehour = string.sub(os.date("%z"), 1, 3)
|
|
local zonemin = string.sub(os.date("%z"), 4, 5)
|
|
dates.rfc3339 = os.date(df.date, time)
|
|
.. os.date("T%H:%M:%S")
|
|
.. "Z"
|
|
.. zonehour
|
|
.. ":"
|
|
.. zonemin
|
|
|
|
dates.time24 = os.date(df.time24, time)
|
|
dates.time12 = os.date(df.time12, time)
|
|
dates.date = os.date(df.date, time)
|
|
dates.prevday = os.date(df.date, time - oneday)
|
|
dates.nextday = os.date(df.date, time + oneday)
|
|
dates.week = os.date(df.week, time)
|
|
dates.prevweek = os.date(df.week, time - oneweek)
|
|
dates.nextweek = os.date(df.week, time + oneweek)
|
|
dates.isoweek = os.date(df.isoweek, time)
|
|
dates.isoprevweek = os.date(df.isoweek, time - oneweek)
|
|
dates.isonextweek = os.date(df.isoweek, time + oneweek)
|
|
|
|
-- things get a bit hairy at the year rollover. W01 only starts the first week ofs
|
|
-- January if it has more than 3 days. Partial weeks with less than 4 days are
|
|
-- considered W52, but os.date still sets the year as the new year, so Jan 1 2022
|
|
-- would appear as being in 2022-W52. That breaks linear linking respective
|
|
-- of next/prev week, so we want to put the days of that partial week in
|
|
-- January in 2021-W52. This tweak will only change the ISO formatted week string.
|
|
if tonumber(dates.week) == 52 and tonumber(dates.month) == 1 then
|
|
dates.isoweek = tostring(dates.year - 1) .. "-W52"
|
|
end
|
|
|
|
-- Find the Sunday that started this week regardless of the calendar
|
|
-- display preference. Then use that as the base to calculate the dates
|
|
-- for the days of the current week.
|
|
-- Finally, adjust Sunday to suit user calendar preference.
|
|
local starting_sunday = time - (wday * oneday)
|
|
local sunday_offset = 0
|
|
if M.Cfg.calendar_opts.calendar_monday == 1 then
|
|
sunday_offset = 7
|
|
end
|
|
dates.monday = os.date(df.date, starting_sunday + (1 * oneday))
|
|
dates.tuesday = os.date(df.date, starting_sunday + (2 * oneday))
|
|
dates.wednesday = os.date(df.date, starting_sunday + (3 * oneday))
|
|
dates.thursday = os.date(df.date, starting_sunday + (4 * oneday))
|
|
dates.friday = os.date(df.date, starting_sunday + (5 * oneday))
|
|
dates.saturday = os.date(df.date, starting_sunday + (6 * oneday))
|
|
dates.sunday = os.date(df.date, starting_sunday + (sunday_offset * oneday))
|
|
|
|
return dates
|
|
end
|
|
|
|
local function linesubst(line, title, dates, uuid)
|
|
if dates == nil then
|
|
dates = calculate_dates()
|
|
end
|
|
if uuid == nil then
|
|
uuid = ""
|
|
end
|
|
|
|
local shorttitle = string.match(title, "^.+/(.+)$")
|
|
if shorttitle == nil then
|
|
shorttitle = title
|
|
end
|
|
|
|
local substs = vim.tbl_extend("error", dates, {
|
|
shorttitle = shorttitle:gsub("^%l", string.upper),
|
|
uuid = uuid,
|
|
title = title:gsub("^%l", string.upper),
|
|
})
|
|
|
|
for k, v in pairs(substs) do
|
|
line = line:gsub("{{" .. k .. "}}", v)
|
|
end
|
|
|
|
return line
|
|
end
|
|
|
|
local function create_note_from_template(
|
|
title,
|
|
uuid,
|
|
filepath,
|
|
templatefn,
|
|
calendar_info
|
|
)
|
|
-- first, read the template file
|
|
local lines = {}
|
|
if file_exists(templatefn) then
|
|
for line in io.lines(templatefn) do
|
|
lines[#lines + 1] = line
|
|
end
|
|
end
|
|
|
|
-- now write the output file, substituting vars line by line
|
|
local ofile = io.open(filepath, "a")
|
|
for _, line in pairs(lines) do
|
|
ofile:write(linesubst(line, title, calendar_info, uuid) .. "\n")
|
|
end
|
|
|
|
ofile:flush()
|
|
ofile:close()
|
|
end
|
|
|
|
--- Pinfo
|
|
--- - fexists : true if file exists
|
|
--- - title : the title (filename including subdirs without extension)
|
|
--- - if opts.subdirs_in_links is false, no subdirs will be included
|
|
--- - filename : filename component only
|
|
--- - filepath : full path, identical to p
|
|
--- - root_dir : the root dir (home, dailies, ...)
|
|
--- - sub_dir : subdir if present, relative to root_dir
|
|
--- - is_daily_or_weekly : bool
|
|
--- - is_daily : bool
|
|
--- - is_weekly : bool
|
|
--- - template : suggested template based on opts
|
|
local Pinfo = {
|
|
fexists = false,
|
|
title = "",
|
|
filename = "",
|
|
filepath = "",
|
|
root_dir = "",
|
|
sub_dir = "",
|
|
is_daily_or_weekly = false,
|
|
is_daily = false,
|
|
is_weekly = false,
|
|
template = "",
|
|
calendar_info = nil,
|
|
}
|
|
|
|
function Pinfo:new(opts)
|
|
opts = opts or {}
|
|
|
|
local object = {}
|
|
setmetatable(object, self)
|
|
self.__index = self
|
|
if opts.filepath then
|
|
return object:resolve_path(opts.filepath, opts)
|
|
end
|
|
if opts.title ~= nil then
|
|
return object:resolve_link(opts.title, opts)
|
|
end
|
|
return object
|
|
end
|
|
|
|
--- resolve_path(p, opts)
|
|
--- inspects the path and returns a Pinfo table
|
|
function Pinfo:resolve_path(p, opts)
|
|
opts = opts or {}
|
|
opts.subdirs_in_links = opts.subdirs_in_links or M.Cfg.subdirs_in_links
|
|
|
|
self.fexists = file_exists(p)
|
|
self.filepath = p
|
|
self.root_dir = M.Cfg.home
|
|
self.is_daily_or_weekly = false
|
|
self.is_daily = false
|
|
self.is_weekly = false
|
|
|
|
-- strip all dirs to get filename
|
|
local pp = Path:new(p)
|
|
local p_splits = pp:_split()
|
|
self.filename = p_splits[#p_splits]
|
|
self.title = self.filename:gsub(M.Cfg.extension, "")
|
|
|
|
if vim.startswith(p, M.Cfg.home) then
|
|
self.root_dir = M.Cfg.home
|
|
end
|
|
if vim.startswith(p, M.Cfg.dailies) then
|
|
self.root_dir = M.Cfg.dailies
|
|
-- TODO: parse "title" into calendarinfo like in resolve_link
|
|
-- not really necessary as the file exists anyway and therefore we don't need to instantiate a template
|
|
self.is_daily_or_weekly = true
|
|
self.is_daily = true
|
|
end
|
|
if vim.startswith(p, M.Cfg.weeklies) then
|
|
-- TODO: parse "title" into calendarinfo like in resolve_link
|
|
-- not really necessary as the file exists anyway and therefore we don't need to instantiate a template
|
|
self.root_dir = M.Cfg.weeklies
|
|
self.is_daily_or_weekly = true
|
|
self.is_weekly = true
|
|
end
|
|
|
|
-- now work out subdir relative to root
|
|
self.sub_dir = p:gsub(escape(self.root_dir .. "/"), "")
|
|
:gsub(escape(self.filename), "")
|
|
:gsub("/$", "")
|
|
:gsub("^/", "")
|
|
|
|
if opts.subdirs_in_links and #self.sub_dir > 0 then
|
|
self.title = self.sub_dir .. "/" .. self.title
|
|
end
|
|
|
|
return self
|
|
end
|
|
|
|
local function check_if_daily_or_weekly(title)
|
|
local daily_match = "^(%d%d%d%d)-(%d%d)-(%d%d)$"
|
|
local weekly_match = "^(%d%d%d%d)-W(%d%d)$"
|
|
|
|
local is_daily = false
|
|
local is_weekly = false
|
|
local dateinfo = calculate_dates() -- sane default
|
|
|
|
local start, _, year, month, day = title:find(daily_match)
|
|
if start ~= nil then
|
|
if tonumber(month) < 13 then
|
|
if tonumber(day) < 32 then
|
|
is_daily = true
|
|
dateinfo.year = tonumber(year)
|
|
dateinfo.month = tonumber(month)
|
|
dateinfo.day = tonumber(day)
|
|
dateinfo = calculate_dates(dateinfo)
|
|
end
|
|
end
|
|
end
|
|
|
|
local week
|
|
start, _, year, week = title:find(weekly_match)
|
|
if start ~= nil then
|
|
if tonumber(week) < 53 then
|
|
is_weekly = true
|
|
-- ISO8601 week -> date calculation
|
|
dateinfo = dateutils.isoweek_to_date(tonumber(year), tonumber(week))
|
|
dateinfo = calculate_dates(dateinfo)
|
|
end
|
|
end
|
|
return is_daily, is_weekly, dateinfo
|
|
end
|
|
|
|
function Pinfo:resolve_link(title, opts)
|
|
opts = opts or {}
|
|
opts.weeklies = opts.weeklies or M.Cfg.weeklies
|
|
opts.dailies = opts.dailies or M.Cfg.dailies
|
|
opts.home = opts.home or M.Cfg.home
|
|
opts.extension = opts.extension or M.Cfg.extension
|
|
opts.template_handling = opts.template_handling or M.Cfg.template_handling
|
|
opts.new_note_location = opts.new_note_location or M.Cfg.new_note_location
|
|
|
|
self.fexists = false
|
|
self.title = title
|
|
self.filename = title .. opts.extension
|
|
self.filename = self.filename:gsub("^%./", "") -- strip potential leading ./
|
|
self.root_dir = opts.home
|
|
self.is_daily_or_weekly = false
|
|
self.is_daily = false
|
|
self.is_weekly = false
|
|
self.template = nil
|
|
self.calendar_info = nil
|
|
|
|
if opts.weeklies and file_exists(opts.weeklies .. "/" .. self.filename) then
|
|
-- TODO: parse "title" into calendarinfo like below
|
|
-- not really necessary as the file exists anyway and therefore we don't need to instantiate a template
|
|
-- if we still want calendar_info, just move the code for it out of `if self.fexists == false`.
|
|
self.filepath = opts.weeklies .. "/" .. self.filename
|
|
self.fexists = true
|
|
self.root_dir = opts.weeklies
|
|
self.is_daily_or_weekly = true
|
|
self.is_weekly = true
|
|
end
|
|
if opts.dailies and file_exists(opts.dailies .. "/" .. self.filename) then
|
|
-- TODO: parse "title" into calendarinfo like below
|
|
-- not really necessary as the file exists anyway and therefore we don't need to instantiate a template
|
|
-- if we still want calendar_info, just move the code for it out of `if self.fexists == false`.
|
|
self.filepath = opts.dailies .. "/" .. self.filename
|
|
self.fexists = true
|
|
self.root_dir = opts.dailies
|
|
self.is_daily_or_weekly = true
|
|
self.is_daily = true
|
|
end
|
|
if file_exists(opts.home .. "/" .. self.filename) then
|
|
self.filepath = opts.home .. "/" .. self.filename
|
|
self.fexists = true
|
|
end
|
|
|
|
if self.fexists == false then
|
|
-- now search for it in all subdirs
|
|
local subdirs = scan.scan_dir(opts.home, { only_dirs = true })
|
|
local tempfn
|
|
for _, folder in pairs(subdirs) do
|
|
tempfn = folder .. "/" .. self.filename
|
|
-- [[testnote]]
|
|
if file_exists(tempfn) then
|
|
self.filepath = tempfn
|
|
self.fexists = true
|
|
-- print("Found: " ..self.filename)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
-- if we just cannot find the note, check if it's a daily or weekly one
|
|
if self.fexists == false then
|
|
-- TODO: if we're not smart, we also shouldn't need to try to set the calendar info..?
|
|
-- I bet someone will want the info in there, so let's put it in if possible
|
|
_, _, self.calendar_info = check_if_daily_or_weekly(self.title) -- will set today as default, so leave in!
|
|
|
|
if opts.new_note_location == "smart" then
|
|
self.filepath = opts.home .. "/" .. self.filename -- default
|
|
self.is_daily, self.is_weekly, self.calendar_info =
|
|
check_if_daily_or_weekly(self.title)
|
|
if self.is_daily == true then
|
|
self.root_dir = opts.dailies
|
|
self.filepath = opts.dailies .. "/" .. self.filename
|
|
self.is_daily_or_weekly = true
|
|
end
|
|
if self.is_weekly == true then
|
|
self.root_dir = opts.weeklies
|
|
self.filepath = opts.weeklies .. "/" .. self.filename
|
|
self.is_daily_or_weekly = true
|
|
end
|
|
elseif opts.new_note_location == "same_as_current" then
|
|
local cwd = vim.fn.expand("%:p")
|
|
if #cwd > 0 then
|
|
self.root_dir = Path:new(cwd):parent():absolute()
|
|
if Path:new(self.root_dir):exists() then
|
|
-- check if potential subfolders in filename would end up in a non-existing directory
|
|
self.filepath = self.root_dir .. "/" .. self.filename
|
|
if not Path:new(self.filepath):parent():exists() then
|
|
print("Path " .. self.filepath .. " is invalid!")
|
|
-- self.filepath = opts.home .. "/" .. self.filename
|
|
end
|
|
else
|
|
print("Path " .. self.root_dir .. " is invalid!")
|
|
-- self.filepath = opts.home .. "/" .. self.filename
|
|
end
|
|
else
|
|
self.filepath = opts.home .. "/" .. self.filename
|
|
end
|
|
else
|
|
-- default fn for creation
|
|
self.filepath = opts.home .. "/" .. self.filename
|
|
end
|
|
|
|
-- final round, there still can be a subdir mess-up
|
|
if not Path:new(self.filepath):parent():exists() then
|
|
print("Path " .. self.filepath .. " is invalid!")
|
|
-- local fname_only = Path:new(self.filename):_split()
|
|
-- fname_only = fname_only[#fname_only]
|
|
-- self.filepath = opts.home .. "/" .. fname_only
|
|
self.filepath = ""
|
|
end
|
|
end
|
|
|
|
-- now work out subdir relative to root
|
|
self.sub_dir = self.filepath
|
|
:gsub(escape(self.root_dir .. "/"), "")
|
|
:gsub(escape(self.filename), "")
|
|
:gsub("/$", "")
|
|
:gsub("^/", "")
|
|
|
|
-- now suggest a template based on opts
|
|
self.template = M.note_type_templates.normal
|
|
if opts.template_handling == "prefer_new_note" then
|
|
self.template = M.note_type_templates.normal
|
|
elseif opts.template_handling == "always_ask" then
|
|
self.template = nil
|
|
elseif opts.template_handling == "smart" then
|
|
if self.is_daily then
|
|
self.template = M.note_type_templates.daily
|
|
elseif self.is_weekly then
|
|
self.template = M.note_type_templates.weekly
|
|
else
|
|
self.template = M.note_type_templates.normal
|
|
end
|
|
end
|
|
|
|
return self
|
|
end
|
|
|
|
-- local function endswith(s, ending)
|
|
-- return ending == "" or s:sub(-#ending) == ending
|
|
-- end
|
|
|
|
local function file_extension(fname)
|
|
return fname:match("^.+(%..+)$")
|
|
end
|
|
|
|
local function filter_filetypes(flist, ftypes)
|
|
local new_fl = {}
|
|
ftypes = ftypes or { M.Cfg.extension }
|
|
|
|
local ftypeok = {}
|
|
for _, ft in pairs(ftypes) do
|
|
ftypeok[ft] = true
|
|
end
|
|
|
|
for _, fn in pairs(flist) do
|
|
if ftypeok[file_extension(fn)] then
|
|
table.insert(new_fl, fn)
|
|
end
|
|
end
|
|
return new_fl
|
|
end
|
|
|
|
local sourced_file = debug_utils.sourced_filepath()
|
|
M.base_directory = vim.fn.fnamemodify(sourced_file, ":h:h:h")
|
|
local media_files_base_directory = M.base_directory
|
|
.. "/telescope-media-files.nvim"
|
|
local defaulter = utils.make_default_callable
|
|
local media_preview = defaulter(function(opts)
|
|
local preview_cmd = ""
|
|
if M.Cfg.media_previewer == "telescope-media-files" then
|
|
preview_cmd = media_files_base_directory .. "/scripts/vimg"
|
|
end
|
|
|
|
if M.Cfg.media_previewer == "catimg-previewer" then
|
|
preview_cmd = M.base_directory
|
|
.. "/telekasten.nvim/scripts/catimg-previewer"
|
|
end
|
|
|
|
if vim.startswith(M.Cfg.media_previewer, "viu-previewer") then
|
|
preview_cmd = M.base_directory
|
|
.. "/telekasten.nvim/scripts/"
|
|
.. M.Cfg.media_previewer
|
|
end
|
|
|
|
if vim.fn.executable(preview_cmd) == 0 then
|
|
print("Previewer not found: " .. preview_cmd)
|
|
return conf.file_previewer(opts)
|
|
end
|
|
return previewers.new_termopen_previewer({
|
|
get_command = opts.get_command
|
|
or function(entry)
|
|
local tmp_table = vim.split(entry.value, "\t")
|
|
local preview = opts.get_preview_window()
|
|
opts.cwd = opts.cwd and vim.fn.expand(opts.cwd)
|
|
or vim.loop.cwd()
|
|
if vim.tbl_isempty(tmp_table) then
|
|
return { "echo", "" }
|
|
end
|
|
print(tmp_table[1])
|
|
return {
|
|
preview_cmd,
|
|
tmp_table[1],
|
|
preview.col,
|
|
preview.line + 1,
|
|
preview.width,
|
|
preview.height,
|
|
}
|
|
end,
|
|
})
|
|
end, {})
|
|
|
|
-- note picker actions
|
|
local picker_actions = {}
|
|
|
|
-- find_files_sorted(opts)
|
|
-- like builtin.find_files, but:
|
|
-- - uses plenary.scan_dir synchronously instead of external jobs
|
|
-- - pre-sorts the file list in descending order (nice for dates, most recent first)
|
|
-- - filters for allowed file types by extension
|
|
-- - (also supports devicons)
|
|
-- - displays subdirs if necessary
|
|
-- - e.g. when searching for daily notes, no subdirs are displayed
|
|
-- - but when entering a date in find_notes, the daily/ and weekly/ subdirs are displayed
|
|
-- - optionally previews media (pdf, images, mp4, webm)
|
|
-- - this requires the telescope-media-files.nvim extension
|
|
local function find_files_sorted(opts)
|
|
opts = opts or {}
|
|
|
|
local file_list = scan.scan_dir(opts.cwd, {})
|
|
local filter_extensions = opts.filter_extensions or M.Cfg.filter_extensions
|
|
file_list = filter_filetypes(file_list, filter_extensions)
|
|
local sort_option = opts.sort or "filename"
|
|
if sort_option == "modified" then
|
|
table.sort(file_list, function(a, b)
|
|
return vim.fn.getftime(a) > vim.fn.getftime(b)
|
|
end)
|
|
else
|
|
table.sort(file_list, function(a, b)
|
|
return a > b
|
|
end)
|
|
end
|
|
|
|
local counts = nil
|
|
if opts.show_link_counts then
|
|
counts = linkutils.generate_backlink_map(M.Cfg)
|
|
end
|
|
|
|
-- display with devicons
|
|
local function iconic_display(display_entry)
|
|
local display_opts = {
|
|
path_display = function(_, e)
|
|
return e:gsub(escape(opts.cwd .. "/"), "")
|
|
end,
|
|
}
|
|
|
|
local hl_group
|
|
local display = utils.transform_path(display_opts, display_entry.value)
|
|
|
|
display, hl_group =
|
|
utils.transform_devicons(display_entry.value, display, false)
|
|
|
|
if hl_group then
|
|
return display, { { { 1, 3 }, hl_group } }
|
|
else
|
|
return display
|
|
end
|
|
end
|
|
|
|
-- for media_files
|
|
local popup_opts = {}
|
|
opts.get_preview_window = function()
|
|
return popup_opts.preview
|
|
end
|
|
|
|
-- local width = config.width
|
|
-- or config.layout_config.width
|
|
-- or config.layout_config[config.layout_strategy].width
|
|
-- or vim.o.columns
|
|
-- local telescope_win_width
|
|
-- if width > 1 then
|
|
-- telescope_win_width = width
|
|
-- else
|
|
-- telescope_win_width = math.floor(vim.o.columns * width)
|
|
-- end
|
|
local displayer = entry_display.create({
|
|
separator = "",
|
|
items = {
|
|
{ width = 4 },
|
|
{ width = 4 },
|
|
{ remaining = true },
|
|
},
|
|
})
|
|
|
|
local function make_display(entry)
|
|
local fn = entry.value
|
|
local nlinks = counts.link_counts[fn] or 0
|
|
local nbacks = counts.backlink_counts[fn] or 0
|
|
|
|
if opts.show_link_counts then
|
|
local display, hl = iconic_display(entry)
|
|
|
|
return displayer({
|
|
{
|
|
"L" .. tostring(nlinks),
|
|
function()
|
|
return {
|
|
{ { 0, 1 }, "tkTagSep" },
|
|
{ { 1, 3 }, "tkTag" },
|
|
}
|
|
end,
|
|
},
|
|
{
|
|
"B" .. tostring(nbacks),
|
|
function()
|
|
return {
|
|
{ { 0, 1 }, "tkTagSep" },
|
|
{ { 1, 3 }, "DevIconMd" },
|
|
}
|
|
end,
|
|
},
|
|
{
|
|
display,
|
|
function()
|
|
return hl
|
|
end,
|
|
},
|
|
})
|
|
else
|
|
return iconic_display(entry)
|
|
end
|
|
end
|
|
|
|
local function entry_maker(entry)
|
|
local iconic_entry = {}
|
|
iconic_entry.value = entry
|
|
iconic_entry.path = entry
|
|
iconic_entry.ordinal = entry
|
|
if opts.show_link_counts then
|
|
iconic_entry.display = make_display
|
|
else
|
|
iconic_entry.display = iconic_display
|
|
end
|
|
return iconic_entry
|
|
end
|
|
|
|
local previewer = conf.file_previewer(opts)
|
|
if opts.preview_type == "media" then
|
|
previewer = media_preview.new(opts)
|
|
end
|
|
|
|
opts.attach_mappings = opts.attach_mappings
|
|
or function(_, _)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
end
|
|
|
|
local picker = pickers.new(opts, {
|
|
finder = finders.new_table({
|
|
results = file_list,
|
|
entry_maker = entry_maker,
|
|
}),
|
|
sorter = conf.generic_sorter(opts),
|
|
|
|
previewer = previewer,
|
|
})
|
|
|
|
-- local oc = picker.finder.close
|
|
--
|
|
-- picker.finder.close = function()
|
|
-- print('on close')
|
|
-- print(vim.inspect(picker:get_selection()))
|
|
-- -- unfortunately, no way to tell if the selection was confirmed or
|
|
-- -- canceled out
|
|
-- oc()
|
|
-- -- alternative: attach default mappings for <ESC> and <C-c>
|
|
-- -- if anyone quits with q!, it's their fault
|
|
-- end
|
|
|
|
-- for media_files:
|
|
local line_count = vim.o.lines - vim.o.cmdheight
|
|
if vim.o.laststatus ~= 0 then
|
|
line_count = line_count - 1
|
|
end
|
|
|
|
popup_opts = picker:get_window_options(vim.o.columns, line_count)
|
|
|
|
picker:find()
|
|
end
|
|
|
|
picker_actions.post_open = function()
|
|
if M.Cfg.auto_set_filetype then
|
|
vim.cmd("set ft=telekasten")
|
|
end
|
|
if M.Cfg.auto_set_syntax then
|
|
vim.cmd("set syntax=telekasten")
|
|
end
|
|
end
|
|
|
|
picker_actions.select_default = function(prompt_bufnr)
|
|
local ret = action_set.select(prompt_bufnr, "default")
|
|
picker_actions.post_open()
|
|
return ret
|
|
end
|
|
|
|
function picker_actions.close(opts)
|
|
opts = opts or {}
|
|
return function(prompt_bufnr)
|
|
actions.close(prompt_bufnr)
|
|
if opts.erase then
|
|
if file_exists(opts.erase_file) then
|
|
vim.fn.delete(opts.erase_file)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function picker_actions.paste_tag(opts)
|
|
return function(prompt_bufnr)
|
|
actions.close(prompt_bufnr)
|
|
local selection = action_state.get_selected_entry()
|
|
vim.api.nvim_put({ selection.value.tag }, "", true, true)
|
|
if opts.insert_after_inserting or opts.i then
|
|
vim.api.nvim_feedkeys("A", "m", false)
|
|
end
|
|
end
|
|
end
|
|
|
|
function picker_actions.yank_tag(opts)
|
|
return function(prompt_bufnr)
|
|
opts = opts or {}
|
|
if opts.close_after_yanking then
|
|
actions.close(prompt_bufnr)
|
|
end
|
|
local selection = action_state.get_selected_entry()
|
|
vim.fn.setreg('"', selection.value.tag)
|
|
print("yanked " .. selection.value.tag)
|
|
end
|
|
end
|
|
|
|
function picker_actions.paste_link(opts)
|
|
opts = opts or {}
|
|
opts.subdirs_in_links = opts.subdirs_in_links or M.Cfg.subdirs_in_links
|
|
return function(prompt_bufnr)
|
|
actions.close(prompt_bufnr)
|
|
local selection = action_state.get_selected_entry()
|
|
local pinfo = Pinfo:new({
|
|
filepath = selection.filename or selection.value,
|
|
opts,
|
|
})
|
|
local title = "[[" .. pinfo.title .. "]]"
|
|
vim.api.nvim_put({ title }, "", true, true)
|
|
if opts.insert_after_inserting or opts.i then
|
|
vim.api.nvim_feedkeys("A", "m", false)
|
|
end
|
|
end
|
|
end
|
|
|
|
function picker_actions.yank_link(opts)
|
|
return function(prompt_bufnr)
|
|
opts = opts or {}
|
|
opts.subdirs_in_links = opts.subdirs_in_links or M.Cfg.subdirs_in_links
|
|
if opts.close_after_yanking then
|
|
actions.close(prompt_bufnr)
|
|
end
|
|
local selection = action_state.get_selected_entry()
|
|
local pinfo = Pinfo:new({
|
|
filepath = selection.filename or selection.value,
|
|
opts,
|
|
})
|
|
local title = "[[" .. pinfo.title .. "]]"
|
|
vim.fn.setreg('"', title)
|
|
print("yanked " .. title)
|
|
end
|
|
end
|
|
|
|
function picker_actions.paste_img_link(opts)
|
|
return function(prompt_bufnr)
|
|
actions.close(prompt_bufnr)
|
|
local selection = action_state.get_selected_entry()
|
|
local fn = selection.value
|
|
fn = make_relative_path(vim.fn.expand("%:p"), fn, "/")
|
|
local imglink = "![](" .. fn .. ")"
|
|
vim.api.nvim_put({ imglink }, "", true, true)
|
|
if opts.insert_after_inserting or opts.i then
|
|
vim.api.nvim_feedkeys("A", "m", false)
|
|
end
|
|
end
|
|
end
|
|
|
|
function picker_actions.yank_img_link(opts)
|
|
return function(prompt_bufnr)
|
|
opts = opts or {}
|
|
if opts.close_after_yanking then
|
|
actions.close(prompt_bufnr)
|
|
end
|
|
local selection = action_state.get_selected_entry()
|
|
local fn = selection.value
|
|
fn = make_relative_path(vim.fn.expand("%:p"), fn, "/")
|
|
local imglink = "![](" .. fn .. ")"
|
|
vim.fn.setreg('"', imglink)
|
|
print("yanked " .. imglink)
|
|
end
|
|
end
|
|
|
|
--
|
|
-- FindDailyNotes:
|
|
-- ---------------
|
|
--
|
|
-- Select from daily notes
|
|
--
|
|
local function FindDailyNotes(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local today = os.date(dateformats.date)
|
|
local fname = M.Cfg.dailies .. "/" .. today .. M.Cfg.extension
|
|
local fexists = file_exists(fname)
|
|
if
|
|
(fexists ~= true)
|
|
and (
|
|
(opts.dailies_create_nonexisting == true)
|
|
or M.Cfg.dailies_create_nonexisting == true
|
|
)
|
|
then
|
|
create_note_from_template(today, _, fname, M.note_type_templates.daily)
|
|
opts.erase = true
|
|
opts.erase_file = fname
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Find daily note",
|
|
cwd = M.Cfg.dailies,
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
sort = M.Cfg.sort,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- FindWeeklyNotes:
|
|
-- ---------------
|
|
--
|
|
-- Select from daily notes
|
|
--
|
|
local function FindWeeklyNotes(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local title = os.date(dateformats.isoweek)
|
|
local fname = M.Cfg.weeklies .. "/" .. title .. M.Cfg.extension
|
|
local fexists = file_exists(fname)
|
|
if
|
|
(fexists ~= true)
|
|
and (
|
|
(opts.weeklies_create_nonexisting == true)
|
|
or M.Cfg.weeklies_create_nonexisting == true
|
|
)
|
|
then
|
|
create_note_from_template(title, _, fname, M.note_type_templates.weekly)
|
|
opts.erase = true
|
|
opts.erase_file = fname
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Find weekly note",
|
|
cwd = M.Cfg.weeklies,
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
sort = M.Cfg.sort,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- InsertLink:
|
|
-- -----------
|
|
--
|
|
-- Select from all notes and put a link in the current buffer
|
|
--
|
|
local function InsertLink(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
opts.subdirs_in_links = opts.subdirs_in_links or M.Cfg.subdirs_in_links
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local cwd = M.Cfg.home
|
|
local find_command = M.Cfg.find_command
|
|
local sort = M.Cfg.sort
|
|
local attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
actions.close(prompt_bufnr)
|
|
local selection = action_state.get_selected_entry()
|
|
local pinfo = Pinfo:new({
|
|
filepath = selection.filename or selection.value,
|
|
opts,
|
|
})
|
|
vim.api.nvim_put({ "[[" .. pinfo.title .. "]]" }, "", false, true)
|
|
if opts.i then
|
|
vim.api.nvim_feedkeys("a", "m", false)
|
|
end
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_link(opts))
|
|
return true
|
|
end
|
|
|
|
if opts.with_live_grep then
|
|
builtin.live_grep({
|
|
prompt_title = "Insert link to note with live grep",
|
|
cwd = cwd,
|
|
attach_mappings = attach_mappings,
|
|
find_command = find_command,
|
|
sort = sort,
|
|
})
|
|
else
|
|
find_files_sorted({
|
|
prompt_title = "Insert link to note",
|
|
cwd = cwd,
|
|
attach_mappings = attach_mappings,
|
|
find_command = find_command,
|
|
sort = sort,
|
|
})
|
|
end
|
|
end
|
|
|
|
-- local function check_for_link_or_tag()
|
|
local function check_for_link_or_tag()
|
|
local line = vim.api.nvim_get_current_line()
|
|
local col = vim.fn.col(".")
|
|
return taglinks.is_tag_or_link_at(line, col, M.Cfg)
|
|
end
|
|
|
|
local function follow_url(url)
|
|
if M.Cfg.follow_url_fallback then
|
|
local cmd = string.gsub(M.Cfg.follow_url_fallback, "{{url}}", url)
|
|
return vim.cmd(cmd)
|
|
end
|
|
|
|
-- we just leave it to the OS's handler to deal with what kind of URL it is
|
|
local function format_command(cmd)
|
|
return 'call jobstart(["'
|
|
.. cmd
|
|
.. '", "'
|
|
.. url
|
|
.. '"], {"detach": v:true})'
|
|
end
|
|
|
|
local command
|
|
if vim.fn.has("mac") == 1 then
|
|
command = format_command("open")
|
|
vim.cmd(command)
|
|
elseif vim.fn.has("unix") then
|
|
command = format_command("xdg-open")
|
|
vim.cmd(command)
|
|
else
|
|
print("Cannot open URLs on your operating system")
|
|
end
|
|
end
|
|
|
|
--
|
|
-- PreviewImg:
|
|
-- -----------
|
|
--
|
|
-- preview media
|
|
--
|
|
local function PreviewImg(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
vim.cmd("normal yi)")
|
|
local fname = vim.fn.getreg('"0'):gsub("^img/", "")
|
|
|
|
-- check if fname exists anywhere
|
|
local imageDir = M.Cfg.image_subdir or M.Cfg.home
|
|
local fexists = file_exists(imageDir .. "/" .. fname)
|
|
|
|
if fexists == true then
|
|
find_files_sorted({
|
|
prompt_title = "Preview image/media",
|
|
cwd = imageDir,
|
|
default_text = fname,
|
|
find_command = M.Cfg.find_command,
|
|
filter_extensions = {
|
|
".png",
|
|
".jpg",
|
|
".bmp",
|
|
".gif",
|
|
".pdf",
|
|
".mp4",
|
|
".webm",
|
|
},
|
|
preview_type = "media",
|
|
|
|
attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
actions.close(prompt_bufnr)
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_img_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_img_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_img_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_img_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_img_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_img_link(opts))
|
|
return true
|
|
end,
|
|
sort = M.Cfg.sort,
|
|
})
|
|
else
|
|
print("File not found: " .. M.Cfg.home .. "/" .. fname)
|
|
end
|
|
end
|
|
|
|
--
|
|
-- BrowseImg:
|
|
-- -----------
|
|
--
|
|
-- preview media
|
|
--
|
|
local function BrowseImg(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Preview image/media",
|
|
cwd = M.Cfg.home,
|
|
find_command = M.Cfg.find_command,
|
|
filter_extensions = {
|
|
".png",
|
|
".jpg",
|
|
".bmp",
|
|
".gif",
|
|
".pdf",
|
|
".mp4",
|
|
".webm",
|
|
},
|
|
preview_type = "media",
|
|
|
|
attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
actions.close(prompt_bufnr)
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_img_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_img_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_img_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_img_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_img_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_img_link(opts))
|
|
return true
|
|
end,
|
|
sort = M.Cfg.sort,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- FindFriends:
|
|
-- -----------
|
|
--
|
|
-- Find notes also linking to the link under cursor
|
|
--
|
|
local function FindFriends(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
vim.cmd("normal yi]")
|
|
local title = vim.fn.getreg('"0')
|
|
title = remove_alias(title)
|
|
title = title:gsub("^(%[)(.+)(%])$", "%2")
|
|
|
|
builtin.live_grep({
|
|
prompt_title = "Notes referencing `" .. title .. "`",
|
|
cwd = M.Cfg.home,
|
|
default_text = "\\[\\[" .. title .. "([#|].+)?\\]\\]",
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_link(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- YankLink:
|
|
-- -----------
|
|
--
|
|
-- Create and yank a [[link]] from the current note.
|
|
--
|
|
local function YankLink()
|
|
local title = "[["
|
|
.. Pinfo:new({ filepath = vim.fn.expand("%:p"), M.Cfg }).title
|
|
.. "]]"
|
|
vim.fn.setreg('"', title)
|
|
print("yanked " .. title)
|
|
end
|
|
|
|
--
|
|
-- RenameNote:
|
|
-- -----------
|
|
--
|
|
-- Prompt for new note title, rename the note and update all links.
|
|
--
|
|
local function RenameNote()
|
|
local oldfile = Pinfo:new({ filepath = vim.fn.expand("%:p"), M.Cfg })
|
|
|
|
tkutils.prompt_title(M.Cfg.extension, function(newname)
|
|
local newpath = newname:match("(.*/)") or ""
|
|
newpath = M.Cfg.home .. "/" .. newpath
|
|
|
|
-- If no subdir specified, place the new note in the same place as old note
|
|
if
|
|
M.Cfg.subdirs_in_links == true
|
|
and newpath == M.Cfg.home .. "/"
|
|
and oldfile.sub_dir ~= ""
|
|
then
|
|
newname = oldfile.sub_dir .. "/" .. newname
|
|
end
|
|
|
|
local fname = M.Cfg.home .. "/" .. newname .. M.Cfg.extension
|
|
local fexists = file_exists(fname)
|
|
if fexists then
|
|
print_error("File alreay exists. Renaming abandonned")
|
|
return
|
|
end
|
|
|
|
-- Savas newfile, delete buffer of old one and remove old file
|
|
if newname ~= "" and newname ~= oldfile.title then
|
|
if not (check_dir_and_ask(newpath, "Renamed file")) then
|
|
return
|
|
end
|
|
|
|
local oldTitle = oldfile.title:gsub(" ", "\\ ")
|
|
vim.cmd(
|
|
"saveas " .. M.Cfg.home .. "/" .. newname .. M.Cfg.extension
|
|
)
|
|
vim.cmd("bdelete " .. oldTitle .. M.Cfg.extension)
|
|
os.execute(
|
|
"rm " .. M.Cfg.home .. "/" .. oldTitle .. M.Cfg.extension
|
|
)
|
|
end
|
|
|
|
if M.Cfg.rename_update_links == true then
|
|
-- Only look for the first part of the link, so we do not touch to #heading or #^paragraph
|
|
-- Should use regex instead to ensure it is a proper link
|
|
local oldlink = "[[" .. oldfile.title
|
|
local newlink = "[[" .. newname
|
|
|
|
-- Save open buffers before looking for links to replace
|
|
if #(vim.fn.getbufinfo({ bufmodified = 1 })) > 1 then
|
|
vim.ui.select({ "Yes (default)", "No" }, {
|
|
prompt = "Telekasten.nvim: "
|
|
.. "Save all modified buffers before updating links?",
|
|
}, function(answer)
|
|
if answer ~= "No" then
|
|
save_all_mod_buffers()
|
|
end
|
|
end)
|
|
end
|
|
|
|
recursive_substitution(M.Cfg.home, oldlink, newlink)
|
|
recursive_substitution(M.Cfg.dailies, oldlink, newlink)
|
|
recursive_substitution(M.Cfg.weeklies, oldlink, newlink)
|
|
end
|
|
end)
|
|
end
|
|
|
|
--
|
|
-- GotoDate:
|
|
-- ----------
|
|
--
|
|
-- find note for date and create it if necessary.
|
|
--
|
|
local function GotoDate(opts)
|
|
opts.dates = calculate_dates(opts.date_table)
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
opts.journal_auto_open = opts.journal_auto_open or M.Cfg.journal_auto_open
|
|
|
|
local word = opts.date or os.date(dateformats.date)
|
|
|
|
local fname = M.Cfg.dailies .. "/" .. word .. M.Cfg.extension
|
|
local fexists = file_exists(fname)
|
|
if
|
|
(fexists ~= true)
|
|
and (
|
|
(opts.dailies_create_nonexisting == true)
|
|
or M.Cfg.dailies_create_nonexisting == true
|
|
)
|
|
then
|
|
create_note_from_template(
|
|
word,
|
|
_,
|
|
fname,
|
|
M.note_type_templates.daily,
|
|
opts.dates
|
|
)
|
|
opts.erase = true
|
|
opts.erase_file = fname
|
|
end
|
|
|
|
if opts.journal_auto_open then
|
|
vim.cmd("e " .. fname)
|
|
else
|
|
find_files_sorted({
|
|
prompt_title = "Goto day",
|
|
cwd = M.Cfg.dailies,
|
|
default_text = word,
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
actions.close(prompt_bufnr)
|
|
|
|
-- open the new note
|
|
if opts.calendar == true then
|
|
vim.cmd("wincmd w")
|
|
end
|
|
vim.cmd("e " .. fname)
|
|
picker_actions.post_open()
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
--
|
|
-- GotoToday:
|
|
-- ----------
|
|
--
|
|
-- find today's daily note and create it if necessary.
|
|
--
|
|
local function GotoToday(opts)
|
|
opts = opts or {}
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local today = os.date(dateformats.date)
|
|
opts.date_table = os.date("*t")
|
|
opts.date = today
|
|
opts.dailies_create_nonexisting = true -- Always use template for GotoToday
|
|
GotoDate(opts)
|
|
end
|
|
|
|
--
|
|
-- FindNotes:
|
|
-- ----------
|
|
--
|
|
-- Select from notes
|
|
--
|
|
local function FindNotes(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local cwd = M.Cfg.home
|
|
local find_command = M.Cfg.find_command
|
|
local sort = M.Cfg.sort
|
|
local attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_link(opts))
|
|
return true
|
|
end
|
|
|
|
if opts.with_live_grep then
|
|
builtin.live_grep({
|
|
prompt_title = "Find notes by live grep",
|
|
cwd = cwd,
|
|
find_command = find_command,
|
|
attach_mappings = attach_mappings,
|
|
sort = sort,
|
|
})
|
|
else
|
|
find_files_sorted({
|
|
prompt_title = "Find notes by name",
|
|
cwd = cwd,
|
|
find_command = find_command,
|
|
attach_mappings = attach_mappings,
|
|
sort = sort,
|
|
})
|
|
end
|
|
end
|
|
|
|
--
|
|
-- InsertImgLink:
|
|
-- --------------
|
|
--
|
|
-- Insert link to image / media, with optional preview
|
|
--
|
|
local function InsertImgLink(opts)
|
|
opts = opts or {}
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Find image/media",
|
|
cwd = M.Cfg.home,
|
|
find_command = M.Cfg.find_command,
|
|
filter_extensions = {
|
|
".png",
|
|
".jpg",
|
|
".bmp",
|
|
".gif",
|
|
".pdf",
|
|
".mp4",
|
|
".webm",
|
|
},
|
|
preview_type = "media",
|
|
|
|
attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
actions.close(prompt_bufnr)
|
|
local selection = action_state.get_selected_entry()
|
|
local fn = selection.value
|
|
fn = make_relative_path(vim.fn.expand("%:p"), fn, "/")
|
|
vim.api.nvim_put({ "![](" .. fn .. ")" }, "", true, true)
|
|
if opts.i then
|
|
vim.api.nvim_feedkeys("A", "m", false)
|
|
end
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_img_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_img_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_img_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_img_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_img_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_img_link(opts))
|
|
return true
|
|
end,
|
|
sort = M.Cfg.sort,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- SearchNotes:
|
|
-- ------------
|
|
--
|
|
-- find the file linked to by the word under the cursor
|
|
--
|
|
local function SearchNotes(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
builtin.live_grep({
|
|
prompt_title = "Search in notes",
|
|
cwd = M.Cfg.home,
|
|
search_dirs = { M.Cfg.home },
|
|
default_text = opts.default_text or vim.fn.expand("<cword>"),
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_link(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- ShowBacklinks:
|
|
-- ------------
|
|
--
|
|
-- Find all notes linking to this one
|
|
--
|
|
local function ShowBacklinks(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local title = Pinfo:new({ filepath = vim.fn.expand("%:p"), M.Cfg }).title
|
|
-- or vim.api.nvim_buf_get_name(0)
|
|
builtin.live_grep({
|
|
results_title = "Backlinks to " .. title,
|
|
prompt_title = "Search",
|
|
cwd = M.Cfg.home,
|
|
search_dirs = { M.Cfg.home },
|
|
default_text = "\\[\\[" .. title .. "([#|].+)?\\]\\]",
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_link(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
|
|
--
|
|
-- CreateNoteSelectTemplate()
|
|
-- --------------------------
|
|
--
|
|
-- Prompts for title, then pops up telescope for template selection,
|
|
-- creates the new note by template and opens it
|
|
|
|
local function on_create_with_template(opts, title)
|
|
if title == nil then
|
|
return
|
|
end
|
|
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
opts.new_note_location = opts.new_note_location or M.Cfg.new_note_location
|
|
opts.template_handling = opts.template_handling or M.Cfg.template_handling
|
|
|
|
local uuid = get_uuid(opts)
|
|
local pinfo = Pinfo:new({
|
|
title = generate_note_filename(uuid, title),
|
|
opts,
|
|
})
|
|
local fname = pinfo.filepath
|
|
if pinfo.fexists == true then
|
|
-- open the new note
|
|
vim.cmd("e " .. fname)
|
|
picker_actions.post_open()
|
|
return
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Select template...",
|
|
cwd = M.Cfg.templates,
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
actions.close(prompt_bufnr)
|
|
-- local template = M.Cfg.templates .. "/" .. action_state.get_selected_entry().value
|
|
local template = action_state.get_selected_entry().value
|
|
-- TODO: pass in the calendar_info returned from the pinfo
|
|
create_note_from_template(
|
|
title,
|
|
uuid,
|
|
fname,
|
|
template,
|
|
pinfo.calendar_info
|
|
)
|
|
-- open the new note
|
|
vim.cmd("e " .. fname)
|
|
picker_actions.post_open()
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
|
|
local function CreateNoteSelectTemplate(opts)
|
|
opts = opts or {}
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
tkutils.prompt_title(M.Cfg.extension, function(title)
|
|
on_create_with_template(opts, title)
|
|
end)
|
|
end
|
|
|
|
--
|
|
-- CreateNote:
|
|
-- ------------
|
|
--
|
|
-- Prompts for title and creates note with default template
|
|
--
|
|
local function on_create(opts, title)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
opts.new_note_location = opts.new_note_location or M.Cfg.new_note_location
|
|
opts.template_handling = opts.template_handling or M.Cfg.template_handling
|
|
|
|
if title == nil then
|
|
return
|
|
end
|
|
|
|
local uuid = get_uuid(opts)
|
|
local pinfo = Pinfo:new({
|
|
title = generate_note_filename(uuid, title),
|
|
opts,
|
|
})
|
|
local fname = pinfo.filepath
|
|
|
|
if pinfo.fexists ~= true then
|
|
-- TODO: pass in the calendar_info returned in pinfo
|
|
create_note_from_template(
|
|
title,
|
|
uuid,
|
|
fname,
|
|
pinfo.template,
|
|
pinfo.calendar_info
|
|
)
|
|
opts.erase = true
|
|
opts.erase_file = fname
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Created note...",
|
|
cwd = pinfo.root_dir,
|
|
default_text = generate_note_filename(uuid, title),
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
|
|
local function CreateNote(opts)
|
|
opts = opts or {}
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
if M.Cfg.template_handling == "always_ask" then
|
|
return CreateNoteSelectTemplate(opts)
|
|
end
|
|
|
|
tkutils.prompt_title(M.Cfg.extension, function(title)
|
|
on_create(opts, title)
|
|
end)
|
|
end
|
|
|
|
--
|
|
-- FollowLink:
|
|
-- -----------
|
|
--
|
|
-- find the file linked to by the word under the cursor
|
|
--
|
|
local function FollowLink(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
|
|
opts.template_handling = opts.template_handling or M.Cfg.template_handling
|
|
opts.new_note_location = opts.new_note_location or M.Cfg.new_note_location
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local search_mode = "files"
|
|
local title
|
|
local filename_part = ""
|
|
|
|
-- first: check if we're in a tag or a link
|
|
local kind, atcol, tag
|
|
local globArg = ""
|
|
|
|
if opts.follow_tag ~= nil then
|
|
kind = "tag"
|
|
tag = opts.follow_tag
|
|
if opts.templateDir ~= nil then
|
|
globArg = "--glob=!" .. "**/" .. opts.templateDir .. "/*.md"
|
|
end
|
|
else
|
|
kind, atcol = check_for_link_or_tag()
|
|
end
|
|
|
|
if kind == "tag" then
|
|
if atcol ~= nil then
|
|
tag = taglinks.get_tag_at(
|
|
vim.api.nvim_get_current_line(),
|
|
atcol,
|
|
M.Cfg
|
|
)
|
|
end
|
|
search_mode = "tag"
|
|
title = tag
|
|
else
|
|
if kind == "link" then
|
|
-- we are in a link
|
|
vim.cmd("normal yi]")
|
|
title = vim.fn.getreg('"0')
|
|
title = title:gsub("^(%[)(.+)(%])$", "%2")
|
|
title = remove_alias(title)
|
|
else
|
|
-- we are in an external [link]
|
|
vim.cmd("normal yi)")
|
|
local url = vim.fn.getreg('"0')
|
|
return follow_url(url)
|
|
end
|
|
|
|
local parts = vim.split(title, "#")
|
|
|
|
-- if there is a #
|
|
if #parts ~= 1 then
|
|
search_mode = "heading"
|
|
title = parts[2]
|
|
filename_part = parts[1]
|
|
parts = vim.split(title, "%^")
|
|
if #parts ~= 1 then
|
|
search_mode = "para"
|
|
title = parts[2]
|
|
end
|
|
end
|
|
|
|
-- this applies to heading and para search_mode
|
|
-- if we cannot find the file, revert to global heading search by
|
|
-- setting filename to empty string
|
|
if #filename_part > 0 then
|
|
local pinfo = Pinfo:new({ title = filename_part })
|
|
filename_part = pinfo.filepath
|
|
if pinfo.fexists == false then
|
|
-- print("error")
|
|
filename_part = ""
|
|
end
|
|
end
|
|
end
|
|
|
|
if search_mode == "files" then
|
|
-- check if fname exists anywhere
|
|
local pinfo = Pinfo:new({ title = title })
|
|
if
|
|
(pinfo.fexists ~= true)
|
|
and (
|
|
(opts.follow_creates_nonexisting == true)
|
|
or M.Cfg.follow_creates_nonexisting == true
|
|
)
|
|
then
|
|
if opts.template_handling == "always_ask" then
|
|
return on_create_with_template(opts, title)
|
|
end
|
|
|
|
if #pinfo.filepath > 0 then
|
|
local uuid = get_uuid(opts)
|
|
create_note_from_template(
|
|
title,
|
|
uuid,
|
|
pinfo.filepath,
|
|
pinfo.template,
|
|
pinfo.calendar_info
|
|
)
|
|
opts.erase = true
|
|
opts.erase_file = pinfo.filepath
|
|
end
|
|
end
|
|
|
|
find_files_sorted({
|
|
prompt_title = "Follow link to note...",
|
|
cwd = pinfo.root_dir,
|
|
default_text = title,
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
sort = M.Cfg.sort,
|
|
})
|
|
end
|
|
|
|
if search_mode ~= "files" then
|
|
local search_pattern = title
|
|
local cwd = M.Cfg.home
|
|
|
|
opts.cwd = cwd
|
|
local counts = nil
|
|
if opts.show_link_counts then
|
|
counts = linkutils.generate_backlink_map(M.Cfg)
|
|
end
|
|
|
|
-- display with devicons
|
|
local function iconic_display(display_entry)
|
|
local display_opts = {
|
|
path_display = function(_, e)
|
|
return e:gsub(escape(opts.cwd .. "/"), "")
|
|
end,
|
|
}
|
|
|
|
local hl_group
|
|
local display =
|
|
utils.transform_path(display_opts, display_entry.value)
|
|
|
|
display_entry.filn = display_entry.filn or display:gsub(":.*", "")
|
|
display, hl_group =
|
|
utils.transform_devicons(display_entry.filn, display, false)
|
|
|
|
if hl_group then
|
|
return display, { { { 1, 3 }, hl_group } }
|
|
else
|
|
return display
|
|
end
|
|
end
|
|
|
|
-- for media_files
|
|
local popup_opts = {}
|
|
opts.get_preview_window = function()
|
|
return popup_opts.preview
|
|
end
|
|
|
|
-- local width = config.width
|
|
-- or config.layout_config.width
|
|
-- or config.layout_config[config.layout_strategy].width
|
|
-- or vim.o.columns
|
|
-- local telescope_win_width
|
|
-- if width > 1 then
|
|
-- telescope_win_width = width
|
|
-- else
|
|
-- telescope_win_width = math.floor(vim.o.columns * width)
|
|
-- end
|
|
local displayer = entry_display.create({
|
|
separator = "",
|
|
items = {
|
|
{ width = 4 },
|
|
{ width = 4 },
|
|
{ remaining = true },
|
|
},
|
|
})
|
|
|
|
local function make_display(entry)
|
|
local fn = entry.filename
|
|
local nlinks = counts.link_counts[fn] or 0
|
|
local nbacks = counts.backlink_counts[fn] or 0
|
|
|
|
if opts.show_link_counts then
|
|
local display, hl = iconic_display(entry)
|
|
|
|
return displayer({
|
|
{
|
|
"L" .. tostring(nlinks),
|
|
function()
|
|
return {
|
|
{ { 0, 1 }, "tkTagSep" },
|
|
{ { 1, 3 }, "tkTag" },
|
|
}
|
|
end,
|
|
},
|
|
{
|
|
"B" .. tostring(nbacks),
|
|
function()
|
|
return {
|
|
{ { 0, 1 }, "tkTagSep" },
|
|
{ { 1, 3 }, "DevIconMd" },
|
|
}
|
|
end,
|
|
},
|
|
{
|
|
display,
|
|
function()
|
|
return hl
|
|
end,
|
|
},
|
|
})
|
|
else
|
|
return iconic_display(entry)
|
|
end
|
|
end
|
|
|
|
local lookup_keys = {
|
|
value = 1,
|
|
ordinal = 1,
|
|
}
|
|
|
|
local find = (function()
|
|
if Path.path.sep == "\\" then
|
|
return function(t)
|
|
local start, _, filn, lnum, col, text =
|
|
string.find(t, [[([^:]+):(%d+):(%d+):(.*)]])
|
|
|
|
-- Handle Windows drive letter (e.g. "C:") at the beginning (if present)
|
|
if start == 3 then
|
|
filn = string.sub(t.value, 1, 3) .. filn
|
|
end
|
|
|
|
return filn, lnum, col, text
|
|
end
|
|
else
|
|
return function(t)
|
|
local _, _, filn, lnum, col, text =
|
|
string.find(t, [[([^:]+):(%d+):(%d+):(.*)]])
|
|
return filn, lnum, col, text
|
|
end
|
|
end
|
|
end)()
|
|
|
|
local parse = function(t)
|
|
-- print("t: ", vim.inspect(t))
|
|
local filn, lnum, col, text = find(t.value)
|
|
|
|
local ok
|
|
ok, lnum = pcall(tonumber, lnum)
|
|
if not ok then
|
|
lnum = nil
|
|
end
|
|
|
|
ok, col = pcall(tonumber, col)
|
|
if not ok then
|
|
col = nil
|
|
end
|
|
|
|
t.filn = filn
|
|
t.lnum = lnum
|
|
t.col = col
|
|
t.text = text
|
|
|
|
return { filn, lnum, col, text }
|
|
end
|
|
|
|
local function entry_maker(_)
|
|
local mt_vimgrep_entry
|
|
|
|
opts = opts or {}
|
|
|
|
-- local disable_devicons = opts.disable_devicons
|
|
-- local disable_coordinates = opts.disable_coordinates or true
|
|
local only_sort_text = opts.only_sort_text
|
|
|
|
local execute_keys = {
|
|
path = function(t)
|
|
if Path:new(t.filename):is_absolute() then
|
|
return t.filename, false
|
|
else
|
|
return Path:new({ t.cwd, t.filename }):absolute(), false
|
|
end
|
|
end,
|
|
|
|
filename = function(t)
|
|
return parse(t)[1], true
|
|
end,
|
|
|
|
lnum = function(t)
|
|
return parse(t)[2], true
|
|
end,
|
|
|
|
col = function(t)
|
|
return parse(t)[3], true
|
|
end,
|
|
|
|
text = function(t)
|
|
return parse(t)[4], true
|
|
end,
|
|
}
|
|
|
|
-- For text search only, the ordinal value is actually the text.
|
|
if only_sort_text then
|
|
execute_keys.ordinal = function(t)
|
|
return t.text
|
|
end
|
|
end
|
|
|
|
mt_vimgrep_entry = {
|
|
cwd = vim.fn.expand(opts.cwd or vim.loop.cwd()),
|
|
|
|
__index = function(t, k)
|
|
local raw = rawget(mt_vimgrep_entry, k)
|
|
if raw then
|
|
return raw
|
|
end
|
|
|
|
local executor = rawget(execute_keys, k)
|
|
if executor then
|
|
local val, save = executor(t)
|
|
if save then
|
|
rawset(t, k, val)
|
|
end
|
|
return val
|
|
end
|
|
|
|
return rawget(t, rawget(lookup_keys, k))
|
|
end,
|
|
}
|
|
|
|
--
|
|
if opts.show_link_counts then
|
|
mt_vimgrep_entry.display = make_display
|
|
else
|
|
mt_vimgrep_entry.display = iconic_display
|
|
end
|
|
|
|
return function(line)
|
|
return setmetatable({ line }, mt_vimgrep_entry)
|
|
end
|
|
end
|
|
|
|
opts.entry_maker = entry_maker(opts)
|
|
|
|
local live_grepper = finders.new_job(
|
|
function(prompt)
|
|
if not prompt or prompt == "" then
|
|
return nil
|
|
end
|
|
|
|
local search_command = {
|
|
"rg",
|
|
"--vimgrep",
|
|
"-e",
|
|
"^#+\\s" .. prompt,
|
|
"--",
|
|
}
|
|
if search_mode == "para" then
|
|
search_command = {
|
|
"rg",
|
|
"--vimgrep",
|
|
"-e",
|
|
"\\^" .. prompt,
|
|
"--",
|
|
}
|
|
end
|
|
|
|
if search_mode == "tag" then
|
|
search_command = {
|
|
"rg",
|
|
"--vimgrep",
|
|
globArg,
|
|
"-e",
|
|
prompt,
|
|
"--",
|
|
}
|
|
end
|
|
|
|
if #filename_part > 0 then
|
|
table.insert(search_command, filename_part)
|
|
else
|
|
table.insert(search_command, cwd)
|
|
end
|
|
|
|
local ret = vim.tbl_flatten({ search_command })
|
|
return ret
|
|
end,
|
|
opts.entry_maker or make_entry.gen_from_vimgrep(opts),
|
|
opts.max_results,
|
|
opts.cwd
|
|
)
|
|
|
|
-- builtin.live_grep({
|
|
local picker = pickers.new({
|
|
cwd = cwd,
|
|
prompt_title = "Notes referencing `" .. title .. "`",
|
|
default_text = search_pattern,
|
|
initial_mode = "insert",
|
|
-- link to specific file (a daily file): [[2021-02-22]]
|
|
-- link to heading in specific file (a daily file): [[2021-02-22#Touchpoint]]
|
|
-- link to heading globally [[#Touchpoint]]
|
|
-- link to heading in specific file (a daily file): [[The cool note#^xAcSh-xxr]]
|
|
-- link to paragraph globally [[#^xAcSh-xxr]]
|
|
finder = live_grepper,
|
|
previewer = conf.grep_previewer(opts),
|
|
sorter = sorters.highlighter_only(opts),
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("i", "<c-cr>", picker_actions.paste_link(opts))
|
|
map("n", "<c-cr>", picker_actions.paste_link(opts))
|
|
return true
|
|
end,
|
|
})
|
|
picker:find()
|
|
end
|
|
end
|
|
|
|
--
|
|
-- GotoThisWeek:
|
|
-- -------------
|
|
--
|
|
-- find this week's weekly note and create it if necessary.
|
|
--
|
|
local function GotoThisWeek(opts)
|
|
opts = opts or {}
|
|
opts.insert_after_inserting = opts.insert_after_inserting
|
|
or M.Cfg.insert_after_inserting
|
|
opts.close_after_yanking = opts.close_after_yanking
|
|
or M.Cfg.close_after_yanking
|
|
opts.journal_auto_open = opts.journal_auto_open or M.Cfg.journal_auto_open
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local dinfo = calculate_dates()
|
|
local title = dinfo.isoweek
|
|
local fname = M.Cfg.weeklies .. "/" .. title .. M.Cfg.extension
|
|
local fexists = file_exists(fname)
|
|
if
|
|
(fexists ~= true)
|
|
and (
|
|
(opts.weeklies_create_nonexisting == true)
|
|
or M.Cfg.weeklies_create_nonexisting == true
|
|
)
|
|
then
|
|
create_note_from_template(title, _, fname, M.note_type_templates.weekly)
|
|
opts.erase = true
|
|
opts.erase_file = fname
|
|
end
|
|
|
|
if opts.journal_auto_open then
|
|
vim.cmd("e " .. fname)
|
|
else
|
|
find_files_sorted({
|
|
prompt_title = "Goto this week:",
|
|
cwd = M.Cfg.weeklies,
|
|
default_text = title,
|
|
find_command = M.Cfg.find_command,
|
|
attach_mappings = function(_, map)
|
|
actions.select_default:replace(picker_actions.select_default)
|
|
map("i", "<c-y>", picker_actions.yank_link(opts))
|
|
map("i", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-y>", picker_actions.yank_link(opts))
|
|
map("n", "<c-i>", picker_actions.paste_link(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
--
|
|
-- Calendar Stuff
|
|
-- --------------
|
|
|
|
-- return if a daily 'note exists' indicator (sign) should be displayed for a particular day
|
|
local function CalendarSignDay(day, month, year)
|
|
local fn = M.Cfg.dailies
|
|
.. "/"
|
|
.. string.format("%04d-%02d-%02d", year, month, day)
|
|
.. M.Cfg.extension
|
|
if file_exists(fn) then
|
|
return 1
|
|
end
|
|
return 0
|
|
end
|
|
|
|
-- action on enter on a specific day:
|
|
-- preview in telescope, stay in calendar on cancel, open note in other window on accept
|
|
local function CalendarAction(day, month, year, _, _)
|
|
local opts = {}
|
|
opts.date = string.format("%04d-%02d-%02d", year, month, day)
|
|
opts.date_table = { year = year, month = month, day = day }
|
|
opts.calendar = true
|
|
GotoDate(opts)
|
|
end
|
|
|
|
local function ShowCalendar(opts)
|
|
local defaults = {}
|
|
defaults.cmd = "CalendarVR"
|
|
defaults.vertical_resize = 1
|
|
|
|
opts = opts or defaults
|
|
vim.cmd(opts.cmd)
|
|
if opts.vertical_resize then
|
|
vim.cmd("vertical resize +" .. opts.vertical_resize)
|
|
end
|
|
vim.cmd([[
|
|
set signcolumn=no
|
|
set nonumber
|
|
set norelativenumber
|
|
]])
|
|
end
|
|
|
|
-- set up calendar integration: forward to our lua functions
|
|
local function SetupCalendar(opts)
|
|
local defaults = M.Cfg.calendar_opts
|
|
opts = opts or defaults
|
|
|
|
local cmd = [[
|
|
function! MyCalSign(day, month, year)
|
|
return luaeval('require("telekasten").CalendarSignDay(_A[1], _A[2], _A[3])', [a:day, a:month, a:year])
|
|
endfunction
|
|
|
|
function! MyCalAction(day, month, year, weekday, dir)
|
|
" day : day
|
|
" month : month
|
|
" year year
|
|
" weekday : day of week (monday=1)
|
|
" dir : direction of calendar
|
|
return luaeval('require("telekasten").CalendarAction(_A[1], _A[2], _A[3], _A[4], _A[5])',
|
|
\ [a:day, a:month, a:year, a:weekday, a:dir])
|
|
endfunction
|
|
|
|
function! MyCalBegin()
|
|
" too early, windown doesn't exist yet
|
|
" cannot resize
|
|
endfunction
|
|
|
|
let g:calendar_sign = 'MyCalSign'
|
|
let g:calendar_action = 'MyCalAction'
|
|
" let g:calendar_begin = 'MyCalBegin'
|
|
|
|
let g:calendar_mark = '{{calendar_mark}}'
|
|
let g:calendar_weeknm = {{weeknm}}
|
|
]]
|
|
|
|
for k, v in pairs(opts) do
|
|
cmd = cmd:gsub("{{" .. k .. "}}", v)
|
|
end
|
|
vim.cmd(cmd)
|
|
if opts.calendar_monday == 1 then
|
|
vim.cmd("let g:calendar_monday = 1")
|
|
end
|
|
end
|
|
|
|
local function ToggleTodo(opts)
|
|
-- replace
|
|
-- by -
|
|
-- - by - [ ]
|
|
-- - [ ] by - [x]
|
|
-- - [x] by -
|
|
-- enter insert mode if opts.i == true
|
|
-- if opts.v = true, then look for marks to toggle
|
|
opts = opts or {}
|
|
local startline = vim.api.nvim_buf_get_mark(0, "<")[1]
|
|
local endline = vim.api.nvim_buf_get_mark(0, ">")[1]
|
|
local cursorlinenr = vim.api.nvim_win_get_cursor(0)[1]
|
|
-- to avoid the visual range marks not being reset when calling
|
|
-- command from normal mode
|
|
vim.api.nvim_buf_set_mark(0, "<", 0, 0, {})
|
|
vim.api.nvim_buf_set_mark(0, ">", 0, 0, {})
|
|
if startline <= 0 or endline <= 0 or opts.v ~= true then
|
|
startline = cursorlinenr
|
|
endline = cursorlinenr
|
|
end
|
|
for curlinenr = startline, endline do
|
|
local curline =
|
|
vim.api.nvim_buf_get_lines(0, curlinenr - 1, curlinenr, false)[1]
|
|
local stripped = vim.trim(curline)
|
|
local repline
|
|
if
|
|
vim.startswith(stripped, "- ")
|
|
and not vim.startswith(stripped, "- [")
|
|
then
|
|
repline = curline:gsub("%- ", "- [ ] ", 1)
|
|
else
|
|
if vim.startswith(stripped, "- [ ]") then
|
|
repline = curline:gsub("%- %[ %]", "- [x]", 1)
|
|
else
|
|
if vim.startswith(stripped, "- [x]") then
|
|
if opts.onlyTodo then
|
|
repline = curline:gsub("%- %[x%]", "- [ ]", 1)
|
|
else
|
|
repline = curline:gsub("%- %[x%]", "-", 1)
|
|
end
|
|
else
|
|
repline = curline:gsub("(%S)", "- [ ] %1", 1)
|
|
end
|
|
end
|
|
end
|
|
vim.api.nvim_buf_set_lines(
|
|
0,
|
|
curlinenr - 1,
|
|
curlinenr,
|
|
false,
|
|
{ repline }
|
|
)
|
|
if opts.i then
|
|
vim.api.nvim_feedkeys("A", "m", false)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function FindAllTags(opts)
|
|
opts = opts or {}
|
|
local i = opts.i
|
|
opts.cwd = M.Cfg.home
|
|
opts.tag_notation = M.Cfg.tag_notation
|
|
local templateDir = Path:new(M.Cfg.templates):make_relative(M.Cfg.home)
|
|
opts.templateDir = templateDir
|
|
opts.rg_pcre = M.Cfg.rg_pcre
|
|
|
|
if not global_dir_check() then
|
|
return
|
|
end
|
|
|
|
local tag_map = tagutils.do_find_all_tags(opts)
|
|
local taglist = {}
|
|
|
|
local max_tag_len = 0
|
|
for k, v in pairs(tag_map) do
|
|
taglist[#taglist + 1] = { tag = k, details = v }
|
|
if #k > max_tag_len then
|
|
max_tag_len = #k
|
|
end
|
|
end
|
|
|
|
if M.Cfg.show_tags_theme == "get_cursor" then
|
|
opts = themes.get_cursor({
|
|
layout_config = {
|
|
height = math.min(math.floor(vim.o.lines * 0.8), #taglist),
|
|
},
|
|
})
|
|
elseif M.Cfg.show_tags_theme == "ivy" then
|
|
opts = themes.get_ivy({
|
|
layout_config = {
|
|
prompt_position = "top",
|
|
height = math.min(math.floor(vim.o.lines * 0.8), #taglist),
|
|
},
|
|
})
|
|
else
|
|
opts = themes.get_dropdown({
|
|
layout_config = {
|
|
prompt_position = "top",
|
|
height = math.min(math.floor(vim.o.lines * 0.8), #taglist),
|
|
},
|
|
})
|
|
end
|
|
-- re-apply
|
|
opts.cwd = M.Cfg.home
|
|
opts.tag_notation = M.Cfg.tag_notation
|
|
opts.i = i
|
|
pickers
|
|
.new(opts, {
|
|
prompt_title = "Tags",
|
|
finder = finders.new_table({
|
|
results = taglist,
|
|
entry_maker = function(entry)
|
|
return {
|
|
value = entry,
|
|
-- display = entry.tag .. ' \t (' .. #entry.details .. ' matches)',
|
|
display = string.format(
|
|
"%" .. max_tag_len .. "s ... (%3d matches)",
|
|
entry.tag,
|
|
#entry.details
|
|
),
|
|
ordinal = entry.tag,
|
|
}
|
|
end,
|
|
}),
|
|
sorter = conf.generic_sorter(opts),
|
|
attach_mappings = function(prompt_bufnr, map)
|
|
actions.select_default:replace(function()
|
|
-- actions for insert tag, default action: search for tag
|
|
local selection =
|
|
action_state.get_selected_entry().value.tag
|
|
local follow_opts = {
|
|
follow_tag = selection,
|
|
show_link_counts = true,
|
|
templateDir = templateDir,
|
|
}
|
|
actions._close(prompt_bufnr, false)
|
|
vim.schedule(function()
|
|
FollowLink(follow_opts)
|
|
end)
|
|
end)
|
|
map("i", "<c-y>", picker_actions.yank_tag(opts))
|
|
map("i", "<c-i>", picker_actions.paste_tag(opts))
|
|
map("n", "<c-y>", picker_actions.yank_tag(opts))
|
|
map("n", "<c-i>", picker_actions.paste_tag(opts))
|
|
map("n", "<c-c>", picker_actions.close(opts))
|
|
map("n", "<esc>", picker_actions.close(opts))
|
|
return true
|
|
end,
|
|
})
|
|
:find()
|
|
end
|
|
|
|
-- Setup(cfg)
|
|
--
|
|
-- Overrides config with elements from cfg. See top of file for defaults.
|
|
--
|
|
local function Setup(cfg)
|
|
cfg = cfg or {}
|
|
defaultConfig(cfg.home)
|
|
local debug = cfg.debug
|
|
for k, v in pairs(cfg) do
|
|
-- merge everything but calendar opts
|
|
-- they will be merged later
|
|
if k ~= "calendar_opts" then
|
|
if k == "home" then
|
|
v = v
|
|
end
|
|
M.Cfg[k] = v
|
|
if debug then
|
|
print(
|
|
"Setup() setting `"
|
|
.. k
|
|
.. "` -> `"
|
|
.. tostring(v)
|
|
.. "`"
|
|
)
|
|
end
|
|
end
|
|
end
|
|
-- TODO: this is obsolete:
|
|
if vim.fn.executable("rg") == 1 then
|
|
M.Cfg.find_command = { "rg", "--files", "--sortr", "created" }
|
|
else
|
|
M.Cfg.find_command = nil
|
|
end
|
|
|
|
-- this looks a little messy
|
|
if M.Cfg.plug_into_calendar then
|
|
cfg.calendar_opts = cfg.calendar_opts or {}
|
|
M.Cfg.calendar_opts = M.Cfg.calendar_opts or {}
|
|
M.Cfg.calendar_opts.weeknm = cfg.calendar_opts.weeknm
|
|
or M.Cfg.calendar_opts.weeknm
|
|
or 1
|
|
M.Cfg.calendar_opts.calendar_monday = cfg.calendar_opts.calendar_monday
|
|
or M.Cfg.calendar_opts.calendar_monday
|
|
or 1
|
|
M.Cfg.calendar_opts.calendar_mark = cfg.calendar_opts.calendar_mark
|
|
or M.Cfg.calendar_opts.calendar_mark
|
|
or "left-fit"
|
|
SetupCalendar(M.Cfg.calendar_opts)
|
|
end
|
|
|
|
-- setup extensions to filter for
|
|
M.Cfg.filter_extensions = cfg.filter_extensions or { M.Cfg.extension }
|
|
|
|
-- provide fake filenames for template loading to fail silently if template is configured off
|
|
M.Cfg.template_new_note = M.Cfg.template_new_note or "none"
|
|
M.Cfg.template_new_daily = M.Cfg.template_new_daily or "none"
|
|
M.Cfg.template_new_weekly = M.Cfg.template_new_weekly or "none"
|
|
|
|
-- refresh templates
|
|
M.note_type_templates = {
|
|
normal = M.Cfg.template_new_note,
|
|
daily = M.Cfg.template_new_daily,
|
|
weekly = M.Cfg.template_new_weekly,
|
|
}
|
|
|
|
-- for previewers to pick up our syntax, we need to tell plenary to override `.md` with our syntax
|
|
if M.Cfg.auto_set_filetype or M.Cfg.auto_set_syntax then
|
|
filetype.add_file("telekasten")
|
|
end
|
|
-- setting the syntax moved into plugin/telekasten.vim
|
|
-- and does not work
|
|
|
|
if M.Cfg.take_over_my_home == true then
|
|
if M.Cfg.auto_set_filetype then
|
|
vim.cmd(
|
|
"au BufEnter "
|
|
.. M.Cfg.home
|
|
.. "/*"
|
|
.. M.Cfg.extension
|
|
.. " set ft=telekasten"
|
|
)
|
|
end
|
|
end
|
|
|
|
if debug then
|
|
print("Resulting config:")
|
|
print("-----------------")
|
|
print(vim.inspect(M.Cfg))
|
|
end
|
|
|
|
-- Convert all directories in full path
|
|
M.Cfg.image_subdir = make_config_path_absolute(M.Cfg.image_subdir)
|
|
M.Cfg.dailies = make_config_path_absolute(M.Cfg.dailies)
|
|
M.Cfg.weeklies = make_config_path_absolute(M.Cfg.weeklies)
|
|
M.Cfg.templates = make_config_path_absolute(M.Cfg.templates)
|
|
|
|
-- Check if ripgrep is compiled with --pcre
|
|
-- ! This will need to be fixed when neovim moves to lua >=5.2 by the following:
|
|
-- M.Cfg.rg_pcre = os.execute("echo 'hello' | rg --pcr2 hello &> /dev/null") or false
|
|
|
|
M.Cfg.rg_pcre = false
|
|
local has_pcre =
|
|
os.execute("echo 'hello' | rg --pcre2 hello > /dev/null 2>&1")
|
|
if has_pcre == 0 then
|
|
M.Cfg.rg_pcre = true
|
|
end
|
|
M.Cfg.media_previewer = M.Cfg.media_previewer
|
|
end
|
|
|
|
local function _setup(cfg)
|
|
if cfg.vaults ~= nil and cfg.default_vault ~= nil then
|
|
M.vaults = cfg.vaults
|
|
cfg.vaults = nil
|
|
Setup(cfg.vaults[cfg.default_vault])
|
|
elseif cfg.vaults ~= nil and cfg.vaults["default"] ~= nil then
|
|
M.vaults = cfg.vaults
|
|
cfg.vaults = nil
|
|
Setup(cfg.vaults["default"])
|
|
elseif cfg.home ~= nil then
|
|
M.vaults = cfg.vaults or {}
|
|
cfg.vaults = nil
|
|
M.vaults["default"] = cfg
|
|
Setup(cfg)
|
|
end
|
|
end
|
|
|
|
local function ChangeVault(opts)
|
|
vaultPicker.vaults(M, opts)
|
|
end
|
|
|
|
local function chdir(cfg)
|
|
Setup(cfg)
|
|
-- M.Cfg = vim.tbl_deep_extend("force", defaultConfig(new_home), cfg)
|
|
end
|
|
|
|
M.find_notes = FindNotes
|
|
M.find_daily_notes = FindDailyNotes
|
|
M.search_notes = SearchNotes
|
|
M.insert_link = InsertLink
|
|
M.follow_link = FollowLink
|
|
M.setup = _setup
|
|
M.goto_today = GotoToday
|
|
M.new_note = CreateNote
|
|
M.goto_thisweek = GotoThisWeek
|
|
M.find_weekly_notes = FindWeeklyNotes
|
|
M.yank_notelink = YankLink
|
|
M.rename_note = RenameNote
|
|
M.new_templated_note = CreateNoteSelectTemplate
|
|
M.show_calendar = ShowCalendar
|
|
M.CalendarSignDay = CalendarSignDay
|
|
M.CalendarAction = CalendarAction
|
|
M.paste_img_and_link = imgFromClipboard
|
|
M.toggle_todo = ToggleTodo
|
|
M.show_backlinks = ShowBacklinks
|
|
M.find_friends = FindFriends
|
|
M.insert_img_link = InsertImgLink
|
|
M.preview_img = PreviewImg
|
|
M.browse_media = BrowseImg
|
|
M.taglinks = taglinks
|
|
M.show_tags = FindAllTags
|
|
M.switch_vault = ChangeVault
|
|
M.chdir = chdir
|
|
|
|
-- Telekasten command, completion
|
|
local TelekastenCmd = {
|
|
commands = function()
|
|
return {
|
|
{ "find notes", "find_notes", M.find_notes },
|
|
{ "find daily notes", "find_daily_notes", M.find_daily_notes },
|
|
{ "search in notes", "search_notes", M.search_notes },
|
|
{ "insert link", "insert_link", M.insert_link },
|
|
{ "follow link", "follow_link", M.follow_link },
|
|
{ "goto today", "goto_today", M.goto_today },
|
|
{ "new note", "new_note", M.new_note },
|
|
{ "goto thisweek", "goto_thisweek", M.goto_thisweek },
|
|
{ "find weekly notes", "find_weekly_notes", M.find_weekly_notes },
|
|
{ "yank link to note", "yank_notelink", M.yank_notelink },
|
|
{ "rename note", "rename_note", M.rename_note },
|
|
{
|
|
"new templated note",
|
|
"new_templated_note",
|
|
M.new_templated_note,
|
|
},
|
|
{ "show calendar", "show_calendar", M.show_calendar },
|
|
{
|
|
"paste image from clipboard",
|
|
"paste_img_and_link",
|
|
M.paste_img_and_link,
|
|
},
|
|
{ "toggle todo", "toggle_todo", M.toggle_todo },
|
|
{ "show backlinks", "show_backlinks", M.show_backlinks },
|
|
{ "find friend notes", "find_friends", M.find_friends },
|
|
{
|
|
"browse images, insert link",
|
|
"insert_img_link",
|
|
M.insert_img_link,
|
|
},
|
|
{ "preview image under cursor", "preview_img", M.preview_img },
|
|
{ "browse media", "browse_media", M.browse_media },
|
|
{ "panel", "panel", M.panel },
|
|
{ "show tags", "show_tags", M.show_tags },
|
|
{ "switch vault", "switch_vault", M.switch_vault },
|
|
}
|
|
end,
|
|
}
|
|
|
|
TelekastenCmd.command = function(subcommand)
|
|
local show = function(opts)
|
|
opts = opts or {}
|
|
pickers
|
|
.new(opts, {
|
|
prompt_title = "Command palette",
|
|
finder = finders.new_table({
|
|
results = TelekastenCmd.commands(),
|
|
entry_maker = function(entry)
|
|
return {
|
|
value = entry,
|
|
display = entry[1],
|
|
ordinal = entry[2],
|
|
}
|
|
end,
|
|
}),
|
|
sorter = conf.generic_sorter(opts),
|
|
attach_mappings = function(prompt_bufnr, _)
|
|
actions.select_default:replace(function()
|
|
-- important: actions.close(bufnr) is not enough
|
|
-- it resulted in: preview_img NOT receiving the prompt as default text
|
|
-- apparently it has sth to do with keeping insert mode
|
|
actions._close(prompt_bufnr, true)
|
|
|
|
local selection =
|
|
action_state.get_selected_entry().value[3]
|
|
selection()
|
|
end)
|
|
return true
|
|
end,
|
|
})
|
|
:find()
|
|
end
|
|
if subcommand then
|
|
-- print("trying subcommand " .. "`" .. subcommand .. "`")
|
|
for _, entry in pairs(TelekastenCmd.commands()) do
|
|
if entry[2] == subcommand then
|
|
local selection = entry[3]
|
|
selection()
|
|
return
|
|
end
|
|
end
|
|
print("No such subcommand: `" .. subcommand .. "`")
|
|
else
|
|
local theme
|
|
|
|
if M.Cfg.command_palette_theme == "ivy" then
|
|
theme = themes.get_ivy()
|
|
else
|
|
theme = themes.get_dropdown({
|
|
layout_config = { prompt_position = "top" },
|
|
})
|
|
end
|
|
show(theme)
|
|
end
|
|
end
|
|
|
|
-- nvim completion function for completing :Telekasten sub-commands
|
|
TelekastenCmd.complete = function()
|
|
local candidates = {}
|
|
for k, v in pairs(TelekastenCmd.commands()) do
|
|
candidates[k] = v[2]
|
|
end
|
|
return candidates
|
|
end
|
|
|
|
M.panel = TelekastenCmd.command
|
|
M.Command = TelekastenCmd
|
|
|
|
-- Load default setup
|
|
Setup()
|
|
|
|
return M
|