if (exists('g:did_buffersaurus') && g:did_buffersaurus) || &cp || version < 700

finish

let g:did_buffersaurus = 1

let s:save_cpo = &cpo

set cpo&vim

if !exists("g:buffersaurus_autodismiss_on_select")

let g:buffersaurus_autodismiss_on_select = 1

if !exists("g:buffersaurus_sort_regime")

let g:buffersaurus_sort_regime = 'fl'

if !exists("g:buffersaurus_show_context")

let g:buffersaurus_show_context = 0

if !exists("g:buffersaurus_context_size")

let g:buffersaurus_context_size = [4, 4]

if !exists("g:buffersaurus_viewport_split_policy")

let g:buffersaurus_viewport_split_policy = "B"

if !exists("g:buffersaurus_move_wrap")

let g:buffersaurus_move_wrap = 1

if !exists("g:buffersaurus_flash_jumped_line")

let g:buffersaurus_flash_jumped_line = 1

let s:buffersaurus_lnum_field_width = 6

let s:buffersaurus_entry_label_field_width = 4

let s:buffersaurus_post_move_cmd = "normal! zz"

let s:buffersaurus_viewport_split_modes = {

\ "d" : "sp",

\ "D" : "sp",

\ "N" : "buffer",

\ "n" : "buffer",

\ "L" : "topleft vert sbuffer",

\ "l" : "leftabove vert sbuffer",

\ "R" : "botright vert sbuffer",

\ "r" : "rightbelow vert sbuffer",

\ "T" : "topleft sbuffer",

\ "t" : "leftabove sbuffer",

\ "B" : "botright sbuffer",

\ "b" : "rightbelow sbuffer",

\ }

let s:buffersaurus_catalog_sort_regimes = ['fl', 'fa', 'a']

let s:buffersaurus_catalog_sort_regime_desc = {

\ 'fl' : ["F(L#)", "by filepath, then by line number"],

\ 'fa' : ["F(A-Z)", "by filepath, then by line text"],

\ 'a' : ["A-Z", "by line text"],

\ 'pl' : ["P(L#)", "by priority, then by line number"],

\ }

function! s:Format_AlignLeft(text, width, fill_char)

let l:fill = repeat(a:fill_char, a:width-len(a:text))

return a:text . l:fill

function! s:Format_AlignRight(text, width, fill_char)

let l:fill = repeat(a:fill_char, a:width-len(a:text))

return l:fill . a:text

function! s:Format_Time(secs)

if exists("*strftime")

return strftime("%Y-%m-%d %H:%M:%S", a:secs)

else

return (localtime() - a:secs) . " secs ago"

endif

function! s:Format_EscapedFilename(file)

if exists('*fnameescape')

return fnameescape(a:file)

else

return escape(a:file," \t\n*?[{`$\\%#'\"|!<")

endif

function! s:Format_Truncate(str, max_len, trunc)

if len(a:str) > a:max_len

if a:trunc > 0

return strpart(a:str, a:max_len - 4) . " ..."

elseif a:trunc < 0

return '... ' . strpart(a:str, len(a:str) - a:max_len + 4)

endif

else

return a:str

endif

function! s:Format_Fill(str, width, align, trunc)

let l:prepped = a:str

if a:trunc != 0

let l:prepped = s:Format_Truncate(a:str, a:width, a:trunc)

endif

if len(l:prepped) < a:width

if a:align > 0

let l:prepped = s:Format_AlignRight(l:prepped, a:width, " ")

elseif a:align < 0

let l:prepped = s:Format_AlignLeft(l:prepped, a:width, " ")

endif

endif

return l:prepped

function! s:NewMessenger(name)

let l:messenger = {}

let l:messenger["name"] = a:name

if empty(a:name)

let l:messenger["title"] = "buffersaurus"

else

let l:messenger["title"] = "buffersaurus (" . l:messenger["name"] . ")"

endif

function! l:messenger.format_message(leader, msg) dict

return self.title . ": " . a:leader.a:msg

endfunction

function! l:messenger.format_exception( msg) dict

return a:msg

endfunction

function! l:messenger.send_error(msg) dict

redraw

echohl ErrorMsg

echomsg self.format_message("[ERROR] ", a:msg)

echohl None

endfunction

function! l:messenger.send_warning(msg) dict

redraw

echohl WarningMsg

echomsg self.format_message("[WARNING] ", a:msg)

echohl None

endfunction

function! l:messenger.send_status(msg) dict

redraw

echohl None

echomsg self.format_message("", a:msg)

endfunction

function! l:messenger.send_info(msg) dict

redraw

echohl None

echo self.format_message("", a:msg)

endfunction

return l:messenger

function! s:NewBufferManager()

let l:buffer_manager = {}

function! l:buffer_manager.get_buf_nums(include_unlisted)

let l:buf_num_list = []

for l:idx in range(1, bufnr("$"))

if bufexists(l:idx) && (empty(a:include_unlisted) || buflisted(l:idx))

call add(l:buf_num_list, l:idx)

endif

endfor

return l:buf_num_list

endfunction

function! l:buffer_manager.get_buf_names(include_unlisted, expand_modifiers)

let l:buf_name_list = []

for l:idx in range(1, bufnr("$"))

if bufexists(l:idx) && (empty(!a:include_unlisted) || buflisted(l:idx))

call add(l:buf_name_list, expand(bufname(l:idx).a:expand_modifiers))

endif

endfor

return l:buf_name_list

endfunction

function! l:buffer_manager.find_windows_with_var(varname, expr)

let l:results = []

for l:wni in range(1, winnr("$"))

let l:wvar = getwinvar(l:wni, "")

if empty(a:varname)

call add(l:results, l:wni)

elseif has_key(l:wvar, a:varname) && l:wvar[a:varname] =~ a:expr

call add(l:results, l:wni)

endif

endfor

return l:results

endfunction

function! l:buffer_manager.find_buffers_with_var(varname, expr)

let l:results = []

for l:bni in range(1, bufnr("$"))

if !bufexists(l:bni)

continue

endif

let l:bvar = getbufvar(l:bni, "")

if empty(a:varname)

call add(l:results, l:bni)

elseif has_key(l:bvar, a:varname) && l:bvar[a:varname] =~ a:expr

call add(l:results, l:bni)

endif

endfor

return l:results

endfunction

function! l:buffer_manager.get_buffers_info(key) dict

if empty(a:key)

let l:key = "num"

else

let l:key = a:key

endif

redir => buffers_output

execute('silent ls')

redir END

let l:buffers_info = {}

let l:buffers_output_rows = split(l:buffers_output, "\n")

for l:buffers_output_row in l:buffers_output_rows

let l:parts = matchlist(l:buffers_output_row, '^\s*\(\d\+\)\(.....\) "\(.*\)"\s\+line \d\+$')

let l:info = {}

let l:info["num"] = l:parts[1] + 0

if l:parts[2][0] == "u"

let l:info["is_unlisted"] = 1

let l:info["is_listed"] = 0

else

let l:info["is_unlisted"] = 0

let l:info["is_listed"] = 1

endif

if l:parts[2][1] == "%"

let l:info["is_current"] = 1

let l:info["is_alternate"] = 0

elseif l:parts[2][1] == "#"

let l:info["is_current"] = 0

let l:info["is_alternate"] = 1

else

let l:info["is_current"] = 0

let l:info["is_alternate"] = 0

endif

if l:parts[2][2] == "a"

let l:info["is_active"] = 1

let l:info["is_loaded"] = 1

let l:info["is_visible"] = 1

elseif l:parts[2][2] == "h"

let l:info["is_active"] = 0

let l:info["is_loaded"] = 1

let l:info["is_visible"] = 0

else

let l:info["is_active"] = 0

let l:info["is_loaded"] = 0

let l:info["is_visible"] = 0

endif

if l:parts[2][3] == "-"

let l:info["is_modifiable"] = 0

let l:info["is_readonly"] = 0

elseif l:parts[2][3] == "="

let l:info["is_modifiable"] = 1

let l:info["is_readonly"] = 1

else

let l:info["is_modifiable"] = 1

let l:info["is_readonly"] = 0

endif

if l:parts[2][4] == "+"

let l:info["is_modified"] = 1

let l:info["is_readerror"] = 0

elseif l:parts[2][4] == "x"

let l:info["is_modified"] = 0

let l:info["is_readerror"] = 0

else

let l:info["is_modified"] = 0

let l:info["is_readerror"] = 0

endif

let l:info["name"] = parts[3]

let l:info["filepath"] = fnamemodify(l:info["name"], ":p")

if !has_key(l:info, l:key)

throw s:_buffersaurus_messenger.format_exception("Invalid key requested: '" . l:key . "'")

endif

let l:buffers_info[l:info[l:key]] = l:info

endfor

return l:buffers_info

endfunction

function! l:buffer_manager.get_split_mode() dict

if has_key(s:buffersaurus_viewport_split_modes, g:buffersaurus_viewport_split_policy)

return s:buffersaurus_viewport_split_modes[g:buffersaurus_viewport_split_policy]

else

call s:_buffersaurus_messenger.send_error("Unrecognized split mode specified by 'g:buffersaurus_viewport_split_policy': " . g:buffersaurus_viewport_split_policy)

endif

endfunction

function! l:buffer_manager:detect_filetype(fname)

let old_eventignore = &eventignore

set eventignore=FileType

let old_filetype = &filetype

exe 'doautocmd filetypedetect BufRead ' . a:fname

let ftype = &filetype

let &filetype = old_filetype

let &eventignore = old_eventignore

return ftype

endfunction

return l:buffer_manager

function! s:NewIndexer()

let l:indexer = {}

let l:indexer["filetype_term_map"] = {

\ 'bib' : '^@\w\+\s*{\s*\zs\S\{-}\ze\s*,'

\ , 'c' : '^[[:alnum:]#].*'

\ , 'cpp' : '^[[:alnum:]#].*'

\ , 'html' : '\(\|<\(html\|head\|body\|div\|script\|a\s\+name=\).\{-}>\|<.\{-}\\)'

\ , 'java' : '^\s*\(\(package\|import\|private\|public\|protected\|void\|int\|boolean\)\s\+\|\u\).*'

\ , 'javascript' : '^\(var\s\+.\{-}\|\s*\w\+\s*:\s*\S.\{-}[,{]\)\s*$'

\ , 'perl' : '^\([$%@]\|\s*\(use\|sub\)\>\).*'

\ , 'php' : '^\(\w\|\s*\(class\|function\|var\|require\w*\|include\w*\)\>\).*'

\ , 'python' : '^\s*\(import\|class\|def\)\s\+[A-Za-z_]\i\+(.*'

\ , 'ruby' : '\C^\(if\>\|\s*\(class\|module\|def\|require\|private\|public\|protected\|module_functon\|alias\|attr\(_reader\|_writer\|_accessor\)\?\)\>\|\s*[[:upper:]_]\+\s*=\).*'

\ , 'scheme' : '^\s*(define.*'

\ , 'sh' : '^\s*\(\(export\|function\|while\|case\|if\)\>\|\w\+\s*()\s*{\).*'

\ , 'tcl' : '^\s*\(source\|proc\)\>.*'

\ , 'tex' : '\C\\\(label\|\(sub\)*\(section\|paragraph\|part\)\)\>.*'

\ , 'vim' : '\C^\(fu\%[nction]\|com\%[mand]\|if\|wh\%[ile]\)\>.*'

\ }

if exists("g:buffersaurus_filetype_term_map")

call extend(l:indexer["filetype_term_map"], g:buffersaurus_filetype_term_map, 'force')

endif

let l:indexer["element_term_map"] = {

\ 'PyClass' : '^\s*class\s\+[A-Za-z_]\i\+(.*'

\ , 'PyDef' : '^\s*def\s\+[A-Za-z_]\i\+(.*'

\ , 'VimFunction' : '^\C[:[:space:]]*fu\%[nction]\>!\=\s*\S\+\s*('

\ , 'VimMapping' : '^\C[:[:space:]]*[nvxsoilc]\=\(\%(nore\|un\)\=map\>\|mapclear\)\>'

\ , 'VimCommand' : '^\C[:[:space:]]*com\%[mand]\>'

\ , 'CppClass' : '^\s*\(\(public\|private\|protected\)\s*:\)\=\s*\(class\|struct\)\s\+\w\+\>\(\s*;\)\@!'

\ , 'CppTypedef' : '^\s*\(\(public\|private\|protected\)\s*:\)\=\s*typedef\>'

\ , 'CppEnum' : '^\s*\(\(public\|private\|protected\)\s*:\)\=\s*enum\>'

\ , 'CppTemplate' : '^\s*template\($\|<\)'

\ , 'CppPreproc' : '^#'

\ }

if exists("g:buffersaurus_element_term_map")

call extend(l:indexer["element_term_map"], g:buffersaurus_element_term_map, 'force')

endif

function! l:indexer.index_terms(filepaths, term_id, sort_regime) dict

let l:old_hidden = &hidden

set hidden

let l:worklist = self.ensure_buffers(a:filepaths)

let l:desc = "Catalog of"

if !empty(a:term_id)

let l:desc .= "'" . a:term_id . "'"

endif

let l:desc .= " terms"

if empty(a:filepaths)

let l:desc .= " (in all buffers)"

elseif len(a:filepaths) == 1

let l:desc .= ' (in "' . expand(a:filepaths[0]) . '")'

else

let l:desc .= " (in multiple files)"

endif

let l:catalog = s:NewCatalog("term", l:desc, a:sort_regime)

for buf_ref in l:worklist

let l:pattern = self.get_buffer_term_pattern(buf_ref, a:term_id)

call l:catalog.map_buffer(buf_ref, l:pattern)

endfor

let &hidden=l:old_hidden

return l:catalog

endfunction

function! l:indexer.index_tags(filepaths) dict

let l:old_hidden = &hidden

set hidden

let l:worklist = self.ensure_buffers(a:filepaths)

let l:desc = "Catalog of tags"

if empty(a:filepaths)

let l:desc .= " (in all buffers)"

elseif len(a:filepaths) == 1

let l:desc .= ' (in "' . a:filepaths[0] . '")'

else

let l:desc .= " (in multiple files)"

endif

let l:catalog = s:NewTagCatalog("tag", l:desc)

for buf_ref in l:worklist

call l:catalog.map_buffer(buf_ref)

endfor

let &hidden=l:old_hidden

return l:catalog

endfunction

function! l:indexer.index_pattern(filepaths, pattern, sort_regime) dict

let l:old_hidden = &hidden

set hidden

let l:worklist = self.ensure_buffers(a:filepaths)

let l:desc = "Catalog of pattern '" . a:pattern . "'"

if empty(a:filepaths)

let l:desc .= " (in all buffers)"

elseif len(a:filepaths) == 1

let l:desc .= ' (in "' . a:filepaths[0] . '")'

else

let l:desc .= " (in multiple files)"

endif

let l:catalog = s:NewCatalog("pattern", l:desc, a:sort_regime)

for buf_ref in l:worklist

call l:catalog.map_buffer(buf_ref, a:pattern)

endfor

let &hidden=l:old_hidden

return l:catalog

endfunction

function! l:indexer.get_buffer_term_pattern(buf_num, term_id) dict

let l:pattern = ""

if !empty(a:term_id)

try

let l:term_id_matches = filter(keys(self.element_term_map),

\ "v:val =~ '" . a:term_id . ".*'")

catch /E15:/

throw s:_buffersaurus_messenger.format_exception("Invalid name: '" . a:term_id . "': ".v:exception)

endtry

if len(l:term_id_matches) > 1

throw s:_buffersaurus_messenger.format_exception("Multiple matches for index pattern name starting with '".a:term_id."': ".join(l:term_id_matches, ", "))

elseif len(l:term_id_matches) == 0

throw s:_buffersaurus_messenger.format_exception("Index pattern with name '" . a:term_id . "' not found")

end

let l:pattern = self.element_term_map[l:term_id_matches[0]]

else

let l:pattern = get(self.filetype_term_map, getbufvar(a:buf_num, "&filetype"), "")

if empty(l:pattern)

let l:pattern = '^\w.*'

endif

endif

return l:pattern

endfunction

function! l:indexer.ensure_buffers(buf_refs)

let l:cur_pos = getpos(".")

let l:cur_buf_num = bufnr("%")

if empty(a:buf_refs)

let l:req_buf_list = s:_buffersaurus_buffer_manager.get_buf_nums(0)

else

let l:req_buf_list = []

for l:buf_ref in a:buf_refs

if type(l:buf_ref) == type(0)

let l:buf_num = l:buf_ref

else

let l:buf_num = bufnr(l:buf_ref)

endif

call add(l:req_buf_list, l:buf_num)

endfor

endif

let l:work_list = []

for l:buf_num in l:req_buf_list

if !bufexists(l:buf_num)

throw s:_buffersaurus_messenger.format_exception('Buffer does not exist: "' . l:buf_num . '"')

elseif !buflisted(l:buf_num)

call s:_buffersaurus_messenger.send_warning('Skipping unlisted buffer: [' . l:buf_num . '] "' . bufname(l:buf_num) . '"')

elseif !empty(getbufvar(l:buf_num, "is_buffersaurus_buffer"))

call s:_buffersaurus_messenger.send_warning('Skipping buffersaurus buffer: [' . l:buf_num . '] "' . bufname(l:buf_num) . '"')

else

call add(l:work_list, l:buf_num)

if !bufloaded(l:buf_num)

execute("silent keepjumps keepalt buffer " . l:buf_num)

endif

endif

endfor

execute("silent keepjumps keepalt buffer ".l:cur_buf_num)

call setpos(".", l:cur_pos)

return l:work_list

endfunction

return l:indexer

function! s:NewCatalog(catalog_domain, catalog_desc, default_sort)

if !exists("s:buffersaurus_catalog_count")

let s:buffersaurus_catalog_count = 1

else

let s:buffersaurus_catalog_count += 1

endif

let l:var_name = a:catalog_domain

let l:catalog = {

\ "catalog_id" : s:buffersaurus_catalog_count,

\ "catalog_domain" : a:catalog_domain,

\ "catalog_desc" : a:catalog_desc,

\ "show_context" : exists("g:buffersaurus_" . l:var_name . "_show_context") ? g:buffersaurus_{l:var_name}_show_context : g:buffersaurus_show_context,

\ "context_size" : exists("g:buffersaurus_" . l:var_name . "_context_size") ? g:buffersaurus_{l:var_name}_context_size : g:buffersaurus_context_size,

\ "search_profile" : [],

\ "matched_lines" : [],

\ "search_history" : [],

\ "searched_files" : {},

\ "last_search_time" : 0,

\ "last_search_hits" : 0,

\ "entry_indexes" : [],

\ "entry_labels" : {},

\ "last_compile_time" : 0,

\ "sort_regime" : empty(a:default_sort) ? g:buffersaurus_sort_regime : a:default_sort,

\}

function! l:catalog.set_context_size(...) dict

let l:context = self.context_size

for l:carg in range(a:0)

if a:000[l:carg] == ""

return

endif

if a:000[l:carg] =~ '\d\+'

let l:context[0] = str2nr(a:000[l:carg])

let l:context[1] = str2nr(a:000[l:carg])

elseif a:000[l:carg] =~ '-\d\+'

let l:context[0] = str2nr(a:000[l:carg][1:])

elseif a:000[l:carg] =! '+\d\+'

let l:context[1] = str2nr(a:000[l:carg][1:])

else

call s:_buffersaurus_messenger.send_error("Invalid argument ".l:carg.": ".a:000[l:carg])

return

endif

endfor

let self.context_size = l:context

return self.context_size

endfunction

function! l:catalog.is_show_context() dict

if !self.show_context

return 0

else

if self.context_size[0] == 0 && self.context_size[1] == 0

return 0

else

return 1

endif

endif

endfunction

function! l:catalog.clear() dict

let self.matched_lines = []

let self.search_history = []

let self.searched_files = {}

let self.last_search_time = 0

let self.last_search_hits = 0

let self.entry_indexes = []

let self.entry_labels = {}

let self.last_compile_time = 0

endfunction

function! l:catalog.size() dict

return len(self.matched_lines)

endfunction

function l:catalog.build(...) dict

call self.clear()

if a:0 >= 1

let self.search_profile = a:1

endif

for l:search in self.search_profile

call self.map_buffer(l:search.filepath, l:search.pattern)

endfor

endfunction

function l:catalog.rebuild() dict

if empty(self.search_history)

raise s:_buffersaurus_messenger.format_exception("Search history is empty")

endif

let self.search_profile = []

for search in self.search_history

call add(self.search_profile, search)

endfor

call self.clear()

call self.build()

call self.compile_entry_indexes()

endfunction

function! l:catalog.map_buffer(buf_ref, pattern) dict

if type(a:buf_ref) == type(0)

let l:buf_num = a:buf_ref

let l:buf_name = bufname(l:buf_num)

else

let l:buf_name = expand(a:buf_ref)

let l:buf_num = bufnr(l:buf_name) + 0

endif

let l:filepath = fnamemodify(expand(l:buf_name), ":p")

let l:buf_search_log = {

\ "buf_name" : l:buf_name,

\ 'buf_num': l:buf_num,

\ "filepath" : l:filepath,

\ "pattern" : a:pattern,

\ "num_lines_searched" : 0,

\ "num_lines_matched" : 0,

\ "last_searched" : 0,

\ }

let self.last_search_hits = 0

let l:lnum = 1

while 1

let l:buf_lines = getbufline(l:buf_num, l:lnum)

if empty(l:buf_lines)

break

endif

let l:pos = match(l:buf_lines[0], a:pattern)

let l:buf_search_log["num_lines_searched"] += 1

if l:pos >= 0

let self.last_search_hits += 1

let l:search_order = len(self.matched_lines) + 1

call add(self.matched_lines, {

\ 'buf_name': l:buf_name,

\ 'buf_num': l:buf_num,

\ 'filepath' : l:filepath,

\ 'lnum': l:lnum,

\ 'col': l:pos + 1,

\ 'sort_text' : substitute(l:buf_lines[0], '^\s*', '', 'g'),

\ 'search_order' : l:search_order,

\ 'entry_label' : string(l:search_order),

\ })

let l:buf_search_log["num_lines_matched"] += 1

endif

let l:lnum += 1

endwhile

let l:buf_search_log["last_searched"] = localtime()

let self.last_search_time = l:buf_search_log["last_searched"]

call add(self.search_history, l:buf_search_log)

if has_key(self.searched_files, l:filepath)

let self.searched_files[l:filepath] += self.last_search_hits

else

let self.searched_files[l:filepath] = self.last_search_hits

endif

endfunction

function! l:catalog.open() dict

if !has_key(self, "catalog_viewer") || empty(self.catalog_viewer)

let self["catalog_viewer"] = s:NewCatalogViewer(self, self.catalog_desc)

endif

call self.catalog_viewer.open()

return self.catalog_viewer

endfunction

function! l:catalog.get_index_groups() dict

if self.last_compile_time < self.last_search_time

call self.compile_entry_indexes()

endif

return self.entry_indexes

endfunction

function! l:catalog.is_sort_grouped() dict

if self.sort_regime == 'a'

return 0

else

return 1

endif

endfunction

function! l:catalog.apply_sort(regime) dict

if index(s:buffersaurus_catalog_sort_regimes, a:regime) == - 1

throw s:_buffersaurus_messenger.format_exception("Unrecognized sort regime: '" . a:regime . "'")

endif

let self.sort_regime = a:regime

return self.compile_entry_indexes()

endfunction

function! l:catalog.cycle_sort_regime() dict

let l:cur_regime = index(s:buffersaurus_catalog_sort_regimes, self.sort_regime)

let l:cur_regime += 1

if l:cur_regime < 0 || l:cur_regime >= len(s:buffersaurus_catalog_sort_regimes)

let self.sort_regime = s:buffersaurus_catalog_sort_regimes[0]

else

let self.sort_regime = s:buffersaurus_catalog_sort_regimes[l:cur_regime]

endif

return self.compile_entry_indexes()

endfunction

function! l:catalog.compile_entry_indexes() dict

let self.entry_indexes = []

let self.entry_labels = {}

if self.sort_regime == 'fl'

call sort(self.matched_lines, "s:compare_matched_lines_fl")

elseif self.sort_regime == 'fa'

call sort(self.matched_lines, "s:compare_matched_lines_fa")

elseif self.sort_regime == 'a'

call sort(self.matched_lines, "s:compare_matched_lines_a")

elseif self.sort_regime == 'pl'

call sort(self.matched_lines, "s:compare_matched_lines_pl")

else

throw s:_buffersaurus_messenger.format_exception("Unrecognized sort regime: '" . self.sort_regime . "'")

endif

if self.sort_regime == 'a'

call add(self.entry_indexes, ['', []])

for l:matched_line_idx in range(0, len(self.matched_lines) - 1)

call add(self.entry_indexes[-1][1], l:matched_line_idx)

let self.entry_labels[l:matched_line_idx] = self.matched_lines[l:matched_line_idx].entry_label

endfor

else

let l:cur_group = ""

for l:matched_line_idx in range(0, len(self.matched_lines) - 1)

if self.matched_lines[l:matched_line_idx].filepath != l:cur_group

let l:cur_group = self.matched_lines[l:matched_line_idx].filepath

call add(self.entry_indexes, [l:cur_group, []])

endif

call add(self.entry_indexes[-1][1], l:matched_line_idx)

let self.entry_labels[l:matched_line_idx] = self.matched_lines[l:matched_line_idx].entry_label

endfor

endif

let self.last_compile_time = localtime()

return self.entry_indexes

endfunction

function! l:catalog.describe() dict

call s:_buffersaurus_messenger.send_info(self.format_status_message() . " (sorted " . self.format_sort_status() . ")")

endfunction

function! l:catalog.describe_detail() dict

echon self.format_status_message() . ":\n"

let l:rows = []

let l:header = self.format_describe_detail_row([

\ "#",

\ "File",

\ "Found",

\ "Total",

\ "Pattern",

\])

echohl Title

echo l:header "\n"

echohl None

for search_log in self.search_history

let l:row = self.format_describe_detail_row([

\ bufnr(search_log.filepath),

\ bufname(search_log.filepath),

\ string(search_log.num_lines_matched),

\ string(search_log.num_lines_searched),

\ search_log.pattern,

\])

call add(l:rows, row)

endfor

echon join(l:rows, "\n")

endfunction

function! l:catalog.format_describe_detail_row(fields)

let l:row = join([

\ s:Format_Fill(a:fields[0], 3, 2, 1),

\ s:Format_Fill(a:fields[1], ((&columns - 14) / 3), -1, -1),

\ s:Format_Fill(a:fields[2], 6, 1, 0),

\ s:Format_Fill(a:fields[3], 6, 1, 0),

\ a:fields[4],

\ ], " ")

return l:row

endfunction

function! l:catalog.format_status_message() dict

let l:message = ""

let l:catalog_size = self.size()

let l:num_searched_files = len(self.searched_files)

if l:catalog_size == 0

let l:message .= "no entries"

elseif l:catalog_size == 1

let l:message .= "1 entry"

else

let l:message .= l:catalog_size . " entries"

endif

let l:message .= " in "

if l:num_searched_files == 0

let l:message .= "no files"

elseif l:num_searched_files == 1

let l:message .= "1 file"

else

let l:message .= l:num_searched_files . " files"

endif

return l:message

endfunction

function! l:catalog.format_sort_status() dict

let l:message = get(s:buffersaurus_catalog_sort_regime_desc, self.sort_regime, ["??", "in unspecified order"])[1]

return l:message

endfunction