732 lines
25 KiB
VimL
732 lines
25 KiB
VimL
" File: autoload/todo.vim
|
||
" Description: Todo.txt sorting plugin
|
||
" Author: David Beniamine <david@beniamine.net>, Peter (fretep) <githib.5678@9ox.net>
|
||
" Licence: Vim licence
|
||
" Website: http://github.com/dbeniamine/todo.txt.vim
|
||
|
||
" These two variables are parameters for the successive calls the vim sort
|
||
" '' means no flags
|
||
" '! i' means reverse and ignore case
|
||
" for more information on flags, see :help sort
|
||
if (! exists("g:Todo_txt_first_level_sort_mode"))
|
||
let g:Todo_txt_first_level_sort_mode='i'
|
||
endif
|
||
if (! exists("g:Todo_txt_second_level_sort_mode"))
|
||
let g:Todo_txt_second_level_sort_mode='i'
|
||
endif
|
||
if (! exists("g:Todo_txt_third_level_sort_mode"))
|
||
let g:Todo_txt_third_level_sort_mode='i'
|
||
endif
|
||
|
||
|
||
" Functions {{{1
|
||
|
||
|
||
function! todo#GetCurpos()
|
||
if exists("*getcurpos")
|
||
return getcurpos()
|
||
endif
|
||
return getpos('.')
|
||
endfunction
|
||
|
||
" Increment and Decrement The Priority.
|
||
" TODO: Make nrformats local to buffers of type todo
|
||
:set nf=octal,hex,alpha
|
||
|
||
function! todo#PrioritizeIncrease()
|
||
normal! 0f)h
|
||
endfunction
|
||
|
||
function! todo#PrioritizeDecrease()
|
||
normal! 0f)h
|
||
endfunction
|
||
|
||
function! todo#PrioritizeAdd (priority)
|
||
let oldpos=todo#GetCurpos()
|
||
let line=getline('.')
|
||
if line !~ '^([A-F])'
|
||
:call todo#PrioritizeAddAction(a:priority)
|
||
let oldpos[2]+=4
|
||
else
|
||
exec ':s/^([A-F])/('.a:priority.')/'
|
||
endif
|
||
call setpos('.',oldpos)
|
||
endfunction
|
||
|
||
function! todo#PrioritizeAddAction (priority)
|
||
execute "normal! mq0i(".a:priority.") \<esc>`q"
|
||
endfunction
|
||
|
||
function! todo#RemovePriority()
|
||
:s/^(\w)\s\+//ge
|
||
endfunction
|
||
|
||
function! todo#PrependDate()
|
||
if (getline(".") =~ '\v^\(')
|
||
execute "normal! 0f)a\<space>\<esc>l\"=strftime(\"%Y-%m-%d\")\<esc>P"
|
||
else
|
||
normal! I=strftime("%Y-%m-%d ")
|
||
endif
|
||
endfunction
|
||
|
||
function! todo#ToggleMarkAsDone(status)
|
||
if (getline(".") =~ '\C^x\s*\d\{4\}')
|
||
:call todo#UnMarkAsDone(a:status)
|
||
else
|
||
:call todo#MarkAsDone(a:status)
|
||
endif
|
||
endfunction
|
||
|
||
function! todo#FixFormat()
|
||
" Remove heading space
|
||
silent! %s/\C^\s*//
|
||
" Remove priority from done tasks
|
||
silent! %s/\C^x (\([A-Z]\)) \(.*\)/x \2 pri:\1/
|
||
endfunction
|
||
|
||
function! todo#UnMarkAsDone(status)
|
||
if a:status==''
|
||
let pat=''
|
||
else
|
||
let pat=' '.a:status
|
||
endif
|
||
exec ':s/\C^x\s*\d\{4}-\d\{1,2}-\d\{1,2}'.pat.'\s*//g'
|
||
silent s/\C\(.*\) pri:\([A-Z]\)/(\2) \1/e
|
||
endfunction
|
||
|
||
function! todo#MarkAsDone(status)
|
||
exec ':s/\C^(\([A-Z]\))\(.*\)/\2 pri:\1/e'
|
||
if a:status!=''
|
||
exec 'normal! I'.a:status.' '
|
||
endif
|
||
call todo#PrependDate()
|
||
if (getline(".") =~ '^ ')
|
||
normal! gIx
|
||
else
|
||
normal! Ix
|
||
endif
|
||
endfunction
|
||
|
||
function! todo#MarkAllAsDone()
|
||
:g!/^x /:call todo#MarkAsDone('')
|
||
endfunction
|
||
|
||
function! s:AppendToFile(file, lines)
|
||
let l:lines = []
|
||
|
||
" Place existing tasks in done.txt at the beggining of the list.
|
||
if filereadable(a:file)
|
||
call extend(l:lines, readfile(a:file))
|
||
endif
|
||
|
||
" Append new completed tasks to the list.
|
||
call extend(l:lines, a:lines)
|
||
|
||
" Write to file.
|
||
call writefile(l:lines, a:file)
|
||
endfunction
|
||
|
||
function! todo#RemoveCompleted()
|
||
" Check if we can write to done.txt before proceeding.
|
||
let l:target_dir = expand('%:p:h')
|
||
if exists("g:TodoTxtForceDoneName")
|
||
let l:done=g:TodoTxtForceDoneName
|
||
else
|
||
let l:done=substitute(substitute(expand('%:t'),'todo','done',''),'Todo','Done','')
|
||
endif
|
||
let l:done_file = l:target_dir.'/'.l:done
|
||
echo "Writing to ".l:done_file
|
||
if !filewritable(l:done_file) && !filewritable(l:target_dir)
|
||
echoerr "Can't write to file '".l:done_file."'"
|
||
return
|
||
endif
|
||
|
||
let l:completed = []
|
||
:g/^x /call add(l:completed, getline(line(".")))|d
|
||
call s:AppendToFile(l:done_file, l:completed)
|
||
endfunction
|
||
|
||
function! todo#Sort()
|
||
" vim :sort is usually stable
|
||
" we sort first on contexts, then on projects and then on priority
|
||
if expand('%')=~'[Dd]one.*.txt'
|
||
" FIXME: Put some unit tests around this, and fix case sensitivity if ignorecase is set.
|
||
silent! %s/\(x\s*\d\{4}\)-\(\d\{2}\)-\(\d\{2}\)/\1\2\3/g
|
||
sort n /^x\s*/
|
||
silent! %s/\(x\s*\d\{4}\)\(\d\{2}\)/\1-\2-/g
|
||
else
|
||
let oldcursor=getpos(".")
|
||
silent normal gg
|
||
let l:first=search('^\s*x')
|
||
if l:first != 0
|
||
sort /^./r
|
||
" at this point done tasks are at the end
|
||
let l:first=search('^\s*x')
|
||
let l:last=search('^\s*x','b')
|
||
let l:diff=l:last-l:first+1
|
||
" Cut the done lines
|
||
execute ':'.l:first.'d a '.l:diff
|
||
endif
|
||
sort /@[a-zA-Z]*/ r
|
||
sort /+[a-zA-Z]*/ r
|
||
sort /\v([A-Z])/ r
|
||
if l:first != 0
|
||
silent normal G"ap
|
||
execute ':'.l:first.','.l:last.'sort /@[a-zA-Z]*/ r'
|
||
execute ':'.l:first.','.l:last.'sort /+[a-zA-Z]*/ r'
|
||
execute ':'.l:first.','.l:last.'sort /\v([A-Z])/ r'
|
||
endif
|
||
call cursor(oldcursor)
|
||
endif
|
||
endfunction
|
||
|
||
function! todo#SortDue()
|
||
" Check how many lines have a due:date on them
|
||
let l:tasksWithDueDate = 0
|
||
silent! %global/\v\c<due:\d{4}-\d{2}-\d{2}>/let l:tasksWithDueDate += 1
|
||
if l:tasksWithDueDate == 0
|
||
" No tasks with a due:date: No need to modify the buffer at all
|
||
" Also means we don't need to cater for no matches on searches below
|
||
return
|
||
endif
|
||
" FIXME: There is a small chance that due:\d{8} might legitimately exist in the buffer
|
||
" We modify due:yyyy-mm-dd to yyyymmdd which would then mean we would alter the buffer
|
||
" in an unexpected way, altering user data. Not sure how to deal with this at the moment.
|
||
" I'm going to throw an exception, and if this is a problem we can revisit.
|
||
silent %global/\v\c<due:\d{8}>/throw "Text matching 'due:\\d\\{8\\}' exists in the buffer, this function cannot sort your buffer"
|
||
" Turn the due:date from due:yyyy-mm-dd to due:yyyymmdd so we can do a numeric sort
|
||
silent! %substitute/\v<(due:\d{4})\-(\d{2})\-(\d{2})>/\1\2\3/ei
|
||
" Sort all the lines with due: by numeric yyyymmdd, they will end up in ascending order at the bottom of the buffer
|
||
sort in /\v\c<due:\ze\d{8}>/
|
||
" Determine the line number of the first task with a due:date
|
||
let l:firstLineWithDue = line("$") - l:tasksWithDueDate + 1
|
||
" Put the sorted lines at the beginning of the file
|
||
if l:firstLineWithDue > 1
|
||
" ...but only if the whole file didn't get sorted.
|
||
execute "silent " . l:firstLineWithDue . ",$move 0"
|
||
endif
|
||
" Change the due:yyyymmdd back to due:yyyy-mm-dd.
|
||
silent! %substitute/\v<(due:\d{4})(\d{2})(\d{2})>/\1-\2-\3/ei
|
||
silent global/\C^x /move$
|
||
" Let's check a global for a user preference on the cursor position.
|
||
if exists("g:TodoTxtSortDueDateCursorPos")
|
||
if g:TodoTxtSortDueDateCursorPos ==? "top"
|
||
normal gg
|
||
elseif g:TodoTxtSortDueDateCursorPos ==? "lastdue" || g:TodoTxtSortDueDateCursorPos ==? "notoverdue"
|
||
silent normal G
|
||
" Sorry for the crazy RegExp. The next command should put cursor at at the top of the completed tasks,
|
||
" or the bottom of the buffer. This is done by searching backwards for any line not starting with
|
||
" "x " (x, space) which is important to distinguish from "xample task" for instance, which the more
|
||
" simple "^[^x]" would match. More info: ":help /\@!". Be sure to enforce case sensitivity on "x".
|
||
:silent! ?\v\C^(x )@!?+1
|
||
let l:overduePat = todo#GetDateRegexForPastDates()
|
||
let l:lastwrapscan = &wrapscan
|
||
set nowrapscan
|
||
try
|
||
if g:TodoTxtSortDueDateCursorPos ==? "lastdue"
|
||
" This searches backwards for the last due task
|
||
:?\v\c<due:\d{4}\-\d{2}\-\d{2}>
|
||
" Try a forward search in case the last line of the buffer was a due:date task, don't match done
|
||
" Be sure to enforce case sensitivity on "x" while allowing mixed case on "due:"
|
||
:silent! /\v\C^(x )@!&.*<[dD][uU][eE]:\d{4}\-\d{2}\-\d{2}>
|
||
elseif g:TodoTxtSortDueDateCursorPos ==? "notoverdue"
|
||
" This searches backwards for the last overdue task, and positions the cursor on the following line
|
||
execute ":?\\v\\c<due:" . l:overduePat . ">?+1"
|
||
endif
|
||
catch
|
||
" Might fail if there are no active (or overdue) due:date tasks. Requires nowrapscan
|
||
" This code path always means we want to be at the top of the buffer
|
||
normal gg
|
||
finally
|
||
let &wrapscan = l:lastwrapscan
|
||
endtry
|
||
elseif g:TodoTxtSortDueDateCursorPos ==? "bottom"
|
||
silent normal G
|
||
endif
|
||
else
|
||
" Default: Top of the document
|
||
normal gg
|
||
endif
|
||
" TODO: add time sorting (YYYY-MM-DD HH:MM)
|
||
endfunction
|
||
|
||
" This is a Hierarchical sort designed for todo.txt todo lists, however it
|
||
" might be used for other files types
|
||
" At the first level, lines are sorted by the word right after the first
|
||
" occurence of a:symbol, there must be no space between the symbol and the
|
||
" word. At the second level, the same kind of sort is done based on
|
||
" a:symbolsub, is a:symbol==' ', the second sort doesn't occurs
|
||
" Therefore, according to todo.txt syntaxt, if
|
||
" a:symbol is a '+' it sort by the first project
|
||
" a:symbol is an '@' it sort by the first context
|
||
" The last level of sort is done directly on the line, so according to
|
||
" todo.txt syntax, it means by priority. This sort is done if and only if the
|
||
" las argument is not 0
|
||
function! todo#HierarchicalSort(symbol, symbolsub, dolastsort)
|
||
if v:statusmsg =~ '--No lines in buffer--'
|
||
"Empty buffer do nothing
|
||
return
|
||
endif
|
||
"if the sort modes doesn't start by '!' it must start with a space
|
||
let l:sortmode=Todo_txt_InsertSpaceIfNeeded(g:Todo_txt_first_level_sort_mode)
|
||
let l:sortmodesub=Todo_txt_InsertSpaceIfNeeded(g:Todo_txt_second_level_sort_mode)
|
||
let l:sortmodefinal=Todo_txt_InsertSpaceIfNeeded(g:Todo_txt_third_level_sort_mode)
|
||
|
||
" Count the number of lines
|
||
let l:position= todo#GetCurpos()
|
||
execute "silent normal G"
|
||
let l:linecount=getpos(".")[1]
|
||
if(exists("g:Todo_txt_debug"))
|
||
echo "Linescount: ".l:linecount
|
||
endif
|
||
execute "silent normal gg"
|
||
|
||
" Get all the groups names
|
||
let l:groups=GetGroups(a:symbol,1,l:linecount)
|
||
if(exists("g:Todo_txt_debug"))
|
||
echo "Groups: "
|
||
echo l:groups
|
||
echo 'execute sort'.l:sortmode.' /.\{-}\ze'.a:symbol.'/'
|
||
endif
|
||
" Sort by groups
|
||
execute 'sort'.l:sortmode.' /.\{-}\ze'.a:symbol.'/'
|
||
for l:g in l:groups
|
||
let l:pat=a:symbol.l:g.'.*$'
|
||
if(exists("g:Todo_txt_debug"))
|
||
echo l:pat
|
||
endif
|
||
normal gg
|
||
" Find the beginning of the group
|
||
let l:groupBegin=search(l:pat,'c')
|
||
" Find the end of the group
|
||
let l:groupEnd=search(l:pat,'b')
|
||
|
||
" I'm too lazy to sort groups of one line
|
||
if(l:groupEnd==l:groupBegin)
|
||
continue
|
||
endif
|
||
if a:dolastsort
|
||
if( a:symbolsub!='')
|
||
" Sort by subgroups
|
||
let l:subgroups=GetGroups(a:symbolsub,l:groupBegin,l:groupEnd)
|
||
" Go before the first line of the group
|
||
" Sort the group using the second symbol
|
||
for l:sg in l:subgroups
|
||
normal gg
|
||
let l:pat=a:symbol.l:g.'.*'.a:symbolsub.l:sg.'.*$\|'.a:symbolsub.l:sg.'.*'.a:symbol.l:g.'.*$'
|
||
" Find the beginning of the subgroup
|
||
let l:subgroupBegin=search(l:pat,'c')
|
||
" Find the end of the subgroup
|
||
let l:subgroupEnd=search(l:pat,'b')
|
||
" Sort by priority
|
||
execute l:subgroupBegin.','.l:subgroupEnd.'sort'.l:sortmodefinal
|
||
endfor
|
||
else
|
||
" Sort by priority
|
||
if(exists("g:Todo_txt_debug"))
|
||
echo 'execute '.l:groupBegin.','.l:groupEnd.'sort'.l:sortmodefinal
|
||
endif
|
||
execute l:groupBegin.','.l:groupEnd.'sort'.l:sortmodefinal
|
||
endif
|
||
endif
|
||
endfor
|
||
" Restore the cursor position
|
||
call setpos('.', position)
|
||
endfunction
|
||
|
||
" Returns the list of groups starting by a:symbol between lines a:begin and
|
||
" a:end
|
||
function! GetGroups(symbol,begin, end)
|
||
let l:curline=a:begin
|
||
let l:groups=[]
|
||
while l:curline <= a:end
|
||
let l:curproj=strpart(matchstr(getline(l:curline),a:symbol.'\S*'),1)
|
||
if l:curproj != "" && index(l:groups,l:curproj) == -1
|
||
let l:groups=add(l:groups , l:curproj)
|
||
endif
|
||
let l:curline += 1
|
||
endwhile
|
||
return l:groups
|
||
endfunction
|
||
|
||
" Insert a space if needed (the first char isn't '!' or ' ') in front of
|
||
" sort parameters
|
||
function! Todo_txt_InsertSpaceIfNeeded(str)
|
||
let l:c=strpart(a:str,1,1)
|
||
if( l:c != '!' && l:c !=' ')
|
||
return " ".a:str
|
||
endif
|
||
retur a:str
|
||
endfunction
|
||
|
||
" function todo#ChangeDueDate {{{2
|
||
function! todo#ChangeDueDate(units, unit_type)
|
||
" Change the due:date on the current line by a number of days, months or
|
||
" years
|
||
"
|
||
" units is the number of unit_type to add or subtract, integer values only
|
||
" unit_type may be one of 'd' (days), 'm' (months) or 'y' (years), as
|
||
" handled by todo#DateAdd
|
||
|
||
let l:currentline = getline('.')
|
||
|
||
" Don't operate on complete tasks
|
||
if l:currentline =~# '^x '
|
||
return
|
||
endif
|
||
|
||
let l:dueDateRex = '\v\c(^|\s)due:\zs\d{4}\-\d{2}\-\d{2}\ze(\s|$)'
|
||
|
||
let l:duedate = matchstr(l:currentline, l:dueDateRex)
|
||
if l:duedate == ''
|
||
" No due date on current line, then add the due date as an offset from
|
||
" current date. I.e. a v:count of 1 is due tomorrow, etc
|
||
if l:currentline =~? '\v\c(^|\s)due:'
|
||
" Has an invalid due: keyword, so don't add another, and don't
|
||
" change the line
|
||
return
|
||
endif
|
||
let l:duedate = strftime('%Y-%m-%d')
|
||
let l:currentline .= ' due:' . l:duedate
|
||
endif
|
||
|
||
let l:duedate = todo#DateStringAdd(l:duedate, v:count1 * a:units, a:unit_type)
|
||
|
||
if setline('.', substitute(l:currentline, l:dueDateRex, l:duedate, '')) != 0
|
||
throw "Failed to set line"
|
||
endif
|
||
endfunction "}}}
|
||
|
||
" General date calculation functions {{{1
|
||
|
||
" function todo#GetDaysInMonth {{{2
|
||
function! todo#GetDaysInMonth(month, year)
|
||
" Given a month and year, returns the number of days in the month, taking
|
||
" leap years into consideration.
|
||
|
||
if index([1, 3, 5, 7, 8, 10, 12], a:month) >= 0
|
||
return 31
|
||
elseif index([4, 6, 9, 11], a:month) >= 0
|
||
return 30
|
||
else
|
||
" February, leap year fun.
|
||
if a:year % 4 != 0
|
||
return 28
|
||
elseif a:year % 100 != 0
|
||
return 29
|
||
elseif a:year % 400 != 0
|
||
return 28
|
||
else
|
||
return 29
|
||
endif
|
||
endif
|
||
endfunction
|
||
|
||
" function todo#DateAdd {{{2
|
||
function! todo#DateAdd(year, month, day, units, unit_type)
|
||
" Add or subtract days, months or years from a date
|
||
"
|
||
" Date must be passed in components of year, month and day, all integers
|
||
" units is the number of unit_type to add or subtract, integer values only
|
||
" unit_type may be one of:
|
||
" d days
|
||
" m months, keeps the day of the month static except in the case
|
||
" that the day is the last day in the month or the day is higher
|
||
" than the number of days in the resultant month, where the result
|
||
" will stick to the end of the month. Examples:
|
||
" 2017-01-15 +1m 2017-02-15 +1m 2017-03-15 +1m 2017-04-15
|
||
" 2017-01-31 +1m 2017-02-28 +1m 2017-03-31 +1m 2017-04-30
|
||
" 2017-01-30 +1m 2017-02-28 +1m 2017-03-31
|
||
" 2017-01-30 +2m 2017-03-30
|
||
" y years
|
||
|
||
|
||
" It is my understanding that VIM does not have date math functionality
|
||
" built in. Given we only have to deal with dates, and not times, it isn't
|
||
" all that scary to roll our own - we just need to watch out for leap years.
|
||
|
||
" Check and clean up input
|
||
if index(["d", "m", "y"], a:unit_type) < 0
|
||
throw 'Invalid unit "'. a:unit_type . '" passed to todo#DateAdd()'
|
||
endif
|
||
|
||
let l:d = str2nr(a:day)
|
||
let l:m = str2nr(a:month)
|
||
let l:y = str2nr(a:year)
|
||
let l:i = str2nr(a:units)
|
||
|
||
" Years can be handled simply as 12 x months
|
||
if a:unit_type == "y"
|
||
let l:utype = "m"
|
||
let l:i = l:i * 12
|
||
else
|
||
let l:utype = a:unit_type
|
||
endif
|
||
|
||
" Check and clean up input
|
||
if l:m < 1
|
||
if l:m == 0
|
||
let l:m = str2nr(strftime('%m'))
|
||
else
|
||
let l:m = 1
|
||
endif
|
||
endif
|
||
if l:m > 12
|
||
if l:i < 0 && l:utype == "m"
|
||
" Subtracting an invalid (high) month
|
||
" See comments for passing a high day below. Same reason for this.
|
||
let l:m = 13
|
||
else
|
||
let l:m = 12
|
||
endif
|
||
endif
|
||
if l:y < 1900 " See end of function for rationale
|
||
if l:y == 0
|
||
let l:y = str2nr(strftime('%Y'))
|
||
else
|
||
let l:y = 1900
|
||
endif
|
||
endif
|
||
|
||
" Grab number of days in the month specified
|
||
let l:daysInMonth = todo#GetDaysInMonth(l:m, l:y)
|
||
|
||
" Check and clean up input
|
||
if l:d < 1
|
||
if l:d == 0
|
||
let l:d = str2nr(strftime('%d'))
|
||
else
|
||
let l:d = 1
|
||
endif
|
||
endif
|
||
" Allow passing a high day, this allows subtraction to be more sane when
|
||
" the day is out of bounds, i.e. 2017-04-80 should probably come out as
|
||
" 2017-04-30 not 2017-04-29. Addition deals with days being out of
|
||
" bounds (high) fine, and if days are untouched, out of bounds user
|
||
" input is caught at the end of the function.
|
||
" if l:d > l:daysInMonth
|
||
" let l:d = l:daysInMonth
|
||
" endif
|
||
|
||
if l:utype == "d"
|
||
" Adding DAYS
|
||
while l:i > 0
|
||
let l:d += 1
|
||
if l:d > l:daysInMonth
|
||
let l:d = 1
|
||
let l:m += 1
|
||
if l:m > 12
|
||
let l:m = 1
|
||
let l:y += 1
|
||
endif
|
||
let l:daysInMonth = todo#GetDaysInMonth(l:m, l:y)
|
||
endif
|
||
let l:i -= 1
|
||
endwhile
|
||
" Subtracting DAYS
|
||
while l:i < 0
|
||
let l:d -= 1
|
||
if l:d < 1
|
||
let l:m -= 1
|
||
if l:m < 1
|
||
if l:y > 1900
|
||
let l:m = 12
|
||
let l:y -= 1
|
||
else
|
||
let l:d = 1
|
||
let l:m = 1
|
||
break
|
||
endif
|
||
endif
|
||
let l:daysInMonth = todo#GetDaysInMonth(l:m, l:y)
|
||
let l:d = l:daysInMonth
|
||
endif
|
||
let l:i += 1
|
||
endwhile
|
||
elseif l:utype == "m"
|
||
if l:d >= l:daysInMonth
|
||
let l:wasLastDayOfMonth = 1
|
||
else
|
||
let l:wasLastDayOfMonth = 0
|
||
endif
|
||
" Adding MONTHS
|
||
while l:i > 0
|
||
let l:m += 1
|
||
if l:m > 12
|
||
let l:m = 1
|
||
let l:y += 1
|
||
endif
|
||
let l:i -= 1
|
||
endwhile
|
||
" Subtracting MONTHS
|
||
while l:i < 0
|
||
let l:m -= 1
|
||
if l:m < 1
|
||
if l:y > 1900
|
||
let l:m = 12
|
||
let l:y -= 1
|
||
else
|
||
let l:m = 1
|
||
endif
|
||
endif
|
||
let l:i += 1
|
||
endwhile
|
||
let l:daysInMonth = todo#GetDaysInMonth(l:m, l:y)
|
||
if l:wasLastDayOfMonth
|
||
let l:d = l:daysInMonth
|
||
endif
|
||
endif
|
||
|
||
" Enforce some limits beyond which, I don't want to support.
|
||
if l:y < 1900
|
||
" Seeing as the date is going to be converted back to a string, dates
|
||
" less that 1000 are bound to cause bugs. Given this is an app for tasks
|
||
" you are doing in the here and now, I'm not supporting way back in the
|
||
" past.
|
||
let l:y = 1900
|
||
let l:daysInMonth = todo#GetDaysInMonth(l:m, l:y)
|
||
endif
|
||
" If we mess with the year (just above), or the user passes a day higher
|
||
" than the month, catch it here.
|
||
if l:d > l:daysInMonth
|
||
let l:d = l:daysInMonth
|
||
endif
|
||
return [l:y, l:m, l:d]
|
||
endfunction
|
||
|
||
" function todo#DateStringAdd {{{2
|
||
function! todo#DateStringAdd(date, units, unit_type)
|
||
" A very thin overload of todo#DateAdd() that takes and returns the date as
|
||
" a string rather than in [year, month, day] component form.
|
||
"
|
||
" Date must be passed in "YYYY-MM-DD" format, and is returned in this form
|
||
" also.
|
||
|
||
let [l:year, l:month, l:day] = todo#ParseDate(a:date)
|
||
let [l:year, l:month, l:day] = todo#DateAdd(l:year, l:month, l:day, a:units, a:unit_type)
|
||
let l:resulting_date = printf('%04d', l:year) . '-' . printf('%02d', l:month) . '-' . printf('%02d', l:day)
|
||
return l:resulting_date
|
||
endfunction
|
||
|
||
" function todo#ParseDate {{{2
|
||
function! todo#ParseDate(datestring)
|
||
" Given a date as a string in the format "YYYY-MM-DD", split the date into a
|
||
" list [year, month, day]
|
||
"
|
||
" Does not check if the date is valid other than being digits. Will throw an
|
||
" exception if the text does not match the expected date format.
|
||
|
||
if a:datestring !~? '\v^(\d{4})\-(\d{2})\-(\d{2})$'
|
||
throw "Invalid date passed '" . a:datestring . "'."
|
||
endif
|
||
let l:year = str2nr(strpart(a:datestring, 0, 4))
|
||
let l:month = str2nr(strpart(a:datestring, 5, 2))
|
||
let l:day = str2nr(strpart(a:datestring, 8, 2))
|
||
return [l:year, l:month, l:day]
|
||
endfunction "}}}
|
||
|
||
" Completion {{{1
|
||
|
||
" Simple keyword completion on all buffers {{{2
|
||
function! TodoKeywordComplete(base)
|
||
" Search for matches
|
||
let res = []
|
||
for bufnr in range(1,bufnr('$'))
|
||
let lines=getbufline(bufnr,1,"$")
|
||
for line in lines
|
||
if line =~ a:base
|
||
" init temporary item
|
||
let item={}
|
||
let item.word=substitute(line,'.*\('.a:base.'\S*\).*','\1',"")
|
||
call add(res,item)
|
||
endif
|
||
endfor
|
||
endfor
|
||
return res
|
||
endfunction
|
||
|
||
" Convert an item to the completion format and add it to the completion list
|
||
fun! TodoAddToCompletionList(list,item,opp)
|
||
" Create the definitive item
|
||
let resitem={}
|
||
let resitem.word=a:item.word
|
||
let resitem.info=a:opp=='+'?"Projects":"Contexts"
|
||
let resitem.info.=": ".join(a:item.related, ", ")
|
||
\."\nBuffers: ".join(a:item.buffers, ", ")
|
||
call add(a:list,resitem)
|
||
endfun
|
||
|
||
fun! TodoCopyTempItem(item)
|
||
let ret={}
|
||
let ret.word=a:item.word
|
||
if has_key(a:item, "related")
|
||
let ret.related=[a:item.related]
|
||
else
|
||
let ret.related=[]
|
||
endif
|
||
let ret.buffers=[a:item.buffers]
|
||
return ret
|
||
endfun
|
||
|
||
" Intelligent completion for projects and Contexts {{{2
|
||
fun! todo#Complete(findstart, base)
|
||
if a:findstart
|
||
let line = getline('.')
|
||
let start = col('.') - 1
|
||
while start > 0 && line[start - 1] !~ '\s'
|
||
let start -= 1
|
||
endwhile
|
||
return start
|
||
else
|
||
if a:base !~ '^+' && a:base !~ '^@'
|
||
return TodoKeywordComplete(a:base)
|
||
endif
|
||
" Opposite sign
|
||
let opp=a:base=~'+'?'@':'+'
|
||
" Search for matchs
|
||
let res = []
|
||
for bufnr in range(1,bufnr('$'))
|
||
let lines=getbufline(bufnr,1,"$")
|
||
for line in lines
|
||
if line =~ " ".a:base
|
||
" init temporary item
|
||
let item={}
|
||
let item.word=substitute(line,'.*\('.a:base.'\S*\).*','\1',"")
|
||
let item.buffers=bufname(bufnr)
|
||
if line =~ '.*\s\('.opp.'\S\S*\).*'
|
||
let item.related=substitute(line,'.*\s\('.opp.'\S\S*\).*','\1',"")
|
||
endif
|
||
call add(res,item)
|
||
endif
|
||
endfor
|
||
endfor
|
||
call sort(res)
|
||
" Here all results are sorted in res, but we need to merge them
|
||
let ret=[]
|
||
if res != []
|
||
let curitem=TodoCopyTempItem(res[0])
|
||
for it in res
|
||
if curitem.word==it.word
|
||
" Merge results
|
||
if has_key(it, "related") && index(curitem.related,it.related) <0
|
||
call add(curitem.related,it.related)
|
||
endif
|
||
if index(curitem.buffers,it.buffers) <0
|
||
call add(curitem.buffers,it.buffers)
|
||
endif
|
||
else
|
||
" Add to list
|
||
call TodoAddToCompletionList(ret,curitem,opp)
|
||
" Init new item from it
|
||
let curitem=TodoCopyTempItem(it)
|
||
endif
|
||
endfor
|
||
" Don't forget to add the list item
|
||
call TodoAddToCompletionList(ret,curitem,opp)
|
||
endif
|
||
return ret
|
||
endif
|
||
endfun
|
||
|
||
" vim: tabstop=4 shiftwidth=4 softtabstop=4 expandtab foldmethod=marker
|