CONTENTS wiki-contents

INTRODUCTION wiki-intro

REQUIREMENTS wiki-intro-requirements

USAGE wiki-intro-usage

FEATURES wiki-intro-features

GUIDE wiki-intro-guide

OTHER USEFUL PLUGINS wiki-intro-plugins

let g:wiki_filetypes = ['wiki']

augroup init_calendar
  autocmd!
  autocmd FileType calendar
        \ nnoremap <silent><buffer> <cr>
        \ :<c-u>call wiki#journal#open()<cr>
augroup END

ALTERNATIVES wiki-intro-alternatives

LINKS wiki-link

http://www.example.com                     link is just a URL
<wiki:a wiki link with spaces>             <…> allows URLs with spaces
[[http://www.example.com]]                 wiki link without description
[[http://www.example.com|a wiki link]]     wiki link with description
[a markdown link](http://www.example.com)  markdown link with description

URL SCHEMES wiki-link-schemes

wiki:index

If the address has whitespace, we need to use a full link style, for
instance:

[[wiki:index#section 1]]

With default settings, wiki link types also imply the wiki scheme, thus
the following is equivalent to the latter:

[[index#section 1]]

journal:2014-03-02
journal:2014-w09
journal:2014-03

SUPPORTED LINK TYPES wiki-link-types

[[URL]]
[[URL|Description]]

[Description](URL)

![Caption text](URL)

[[URL]]
[[URL][Description]]

The most simple form, and perhaps the most useful one, is to add a simple
reference like this [1].

One may also add a [description][label].

The target may consist of both words and numbers, e.g. [like this][Ref 3].

[1]: <URL 1>
[label]: <URL 2>
[Ref 3]: <URL 3>

Bracket style
  <<anchor>>
  <<anchor,Description>>
  <<filename.adoc#anchor>>
  <<filename.adoc#anchor,Description>>

Inline macro
  xref:anchor[Description]
  xref:filename.adoc#anchor[Description]
  xref:[LONG URL][Description]

link:<target>[<attrlist>]

OPTIONS wiki-options

let g:wiki_export = {
      \ 'args' : '',
      \ 'from_format' : 'markdown',
      \ 'ext' : 'pdf',
      \ 'link_ext_replace': v:false,
      \ 'view' : v:false,
      \ 'output': fnamemodify(tempname(), ':h'),
      \}

let g:wiki_fzf_pages_opts = '--preview "cat {1}"'

let g:wiki_fzf_tags_opts = '--preview "bat --color=always {2..}"'

vim.g.wiki_select_method = {
  pages = require("wiki.ui_select").pages,
  tags = require("wiki.ui_select").tags,
  toc = require("wiki.ui_select").toc,
  links = require("wiki.ui_select").links,
}

let g:wiki_select_method = {
      \ 'pages': function('wiki#fzf#pages'),
      \ 'tags': function('wiki#fzf#tags'),
      \ 'toc': function('wiki#fzf#toc'),
      \ 'links': function('wiki#fzf#links'),
      \}

let g:wiki_journal = {
      \ 'date_format': {
      \   'daily' : '%Y/%m/%d',
      \   'weekly' : '%Y/week_%V',
      \   'monthly' : '%Y/%m/summary',
      \ },
      \}

wiki/journal
├── 2021
│   ├── week_01.wiki
│   ├── week_02.wiki
│   └── 04
│       ├── summary.wiki
│       ├── 25.wiki
│       └── 26.wiki
└── 2022
    └── 06
        ├── 25.wiki
        └── 26.wiki

let g:wiki_journal = {
      \ 'name': 'journal',
      \ 'root': '',
      \ 'frequency': 'daily',
      \ 'date_format': {
      \   'daily' : '%Y-%m-%d',
      \   'weekly' : '%Y_w%V',
      \   'monthly' : '%Y_m%m',
      \ },
      \}

" Use the file basename
let g:wiki_journal_index = {
      \ 'link_text_parser': { b, d, p -> b }
      \}

" Use the isodate. This works well as long as there is only a single
" journal entry per date.
let g:wiki_journal_index = {
      \ 'link_text_parser': { b, d, p -> d }
      \}

" Extract and use first header of the file
let g:wiki_journal_index = {
      \ 'link_text_parser': { b, d, p -> wiki#toc#get_page_title(p) }
      \}

" Use the path from wiki root (this is usually a good alternative to
" the default journal: scheme)
let g:wiki_journal_index = {
      \ 'link_url_parser': { b, d, p -> p }
      \}

" Use relative path from current file (i.e. file where you are making
" the index)
let g:wiki_journal_index = {
      \ 'link_url_parser': { b, d, p ->
      \   wiki#paths#relative(p, expand('%:p:h'))
      \ }
      \}

let g:wiki_journal_index = {
      \ 'reverse': v:false,
      \ 'link_text_parser': { b, d, p -> d },
      \ 'link_url_parser': { b, d, p -> 'journal:' . d }
      \}

let g:wiki_link_creation = {
      \ 'md': {
      \   'url_transform': { x ->
      \     substitute(tolower(x), '\s\+', '-', 'g') },
      \ },
      \}

    let g:wiki_link_creation = {
          \ 'md': {
          \   'path_transform': { x ->
          \     fnamemodify(
          \       wiki#paths#relative(x, expand('%:p')),
          \       ':h'
          \     )
          \   },
          \ },
          \}

link_text ~
  A |Funcref| for a function used by |WikiLinkAdd| to determine the link
  text of the added link. This can also be an |anonymous-function|. If it
  is undefined, the default link text is empty.
    The function requires a single string argument, which is the path to
  the link target. It should return a string - the desired link text.

let g:wiki_link_default_schemes = {
      \ 'wiki': { 'wiki': 'wiki', 'adoc': 'adoc' },
      \ 'md': 'md',
      \ 'md_fig': 'file',
      \ 'org': 'wiki',
      \ 'adoc_xref_inline': 'adoc',
      \ 'adoc_xref_bracket': 'adoc',
      \ 'adoc_link': 'file',
      \ 'ref_target': '',
      \ 'date': 'journal',
      \ 'cite': 'zot',
      \}

let l:url = {
      \ 'url': 'URL HERE',
      \ 'scheme': 'SCHEME',
      \ 'stripped': 'URL WITHOUT SCHEME',
      \ 'origin': 'THE ORIGIN FILE'
      \}

function TransformWikiToMd(url, text, link) abort dict
  return wiki#link#templates#md(
        \ a:url . '.wiki',
        \ empty(a:text) ? a:url : a:text,
        \ a:link)
endfunction

function TransformMdToWiki(url, text, link) abort dict
  let l:url = substitute(a:url, '\.wiki$', '', '')
  return wiki#link#templates#wiki(l:url, a:text, a:link)
endfunction

let g:wiki_link_transforms = {
      \ 'md': 'TransformMdToWiki',
      \ 'wiki': 'TransformWikiToMd',
      \}

let g:wiki_mappings_global = {
    \ '<plug>(wiki-reload)' : ',wx',
    \}

let g:wiki_mappings_local = {
      \ '<plug>(wiki-export)' : '<c-p>',
      \ 'x_<plug>(wiki-export)' : '<c-p>',
      \}

let g:wiki_mappings_local_journal = {
      \ '<plug>(wiki-journal-prev)' : '[w',
      \ '<plug>(wiki-journal-next)' : ']w',
      \}

let g:wiki_mappings_local_journal = {
      \ '<plug>(wiki-tag-list)': '',
      \ '<plug>(wiki-tag-search)': '',
      \ '<plug>(wiki-tag-reload)': '',
      \ '<plug>(wiki-tag-rename)': '',
      \}

function! WikiRoot()
  let l:local = finddir('wiki', ';./')
  return !empty(l:local) ? l:local : '~/wiki'
endfunction

let g:wiki_root = 'WikiRoot'

let g:wiki_toc_filetypes = {
      \ '_' : 'markdown',
      \ 'md' : 'markdown',
      \ 'adoc' : 'asciidoc',
      \ 'org' : 'org',
      \}

let g:wiki_tag_list = {
      \ 'output' : 'loclist',
      \}

let g:wiki_tag_search = {
      \ 'output' : 'loclist',
      \}

let g:wiki_tag_parsers = [
      \ g:wiki#tags#default_parser,
      \ { 'match': {x -> x =~# '^tags: '},
      \   'parse': {x -> split(matchstr(x, '^tags:\zs.*'), '[ ,]\+')},
      \   'make':  {t, x -> 'tags: ' . empty(t) ? '' : join(t, ', ')}}
      \]

let g:wiki_tag_parsers = [g:wiki#tags#default_parser]

let g:wiki_tag_scan_num_lines = -10

let g:wiki_tag_scan_num_lines = 'all'

let g:wiki_tag_scan_num_lines = 15

function! TemplateFallback(context)
  call append(0, '# ' . a:context.name)
  call append(1, '')
  call append(2, 'Foobar')
endfunction

let g:wiki_templates = [
      \ { 'match_re': 'index',
      \   'source_filename': '/home/user/templates/index.md'},
      \ { 'match_re': 'foo',
      \   'source_filename': '.footemplate.md'},
      \ { 'match_func': {x -> v:true},
      \   'source_func': function('TemplateFallback')},
      \]

" On neovim
let g:wiki_ui_method = {
      \ 'confirm': 'nvim',
      \ 'input': 'nvim',
      \ 'select': 'nvim',
      \}

" Otherwise
let g:wiki_ui_method = {
      \ 'confirm': 'legacy',
      \ 'input': 'legacy',
      \ 'select': 'legacy',
      \}

" Common
let g:wiki_viewer = {
      \ 'md' : ':edit',
      \ 'wiki' : ':edit'
      \}

" Linux
let g:wiki_viewer._ = 'xdg-open'

" MacOS
let g:wiki_viewer._ = 'open'

EVENTS wiki-events

augroup MyWikiAutocmds
  autocmd!
  autocmd User WikiLinkFollowed normal! zz
  autocmd User WikiBufferInitialized
        \ nmap <buffer> gf <plug>(wiki-link-follow)
  autocmd User WikiBufferInitialized WikiLinkIncomingToggle
augroup END

MAPPINGS AND COMMANDS wiki-mappings

DEFAULT MAPPINGS wiki-mappings-default

MAPPINGS AND COMMANDS REFERENCE wiki-mappings-reference

augroup MyWikiAutocmds
  autocmd!
  autocmd User WikiLinkFollowed normal! zz
augroup END

:vert topleft WikiLinkfollowSplit

COMPLETION wiki-completion

TAGS wiki-tags

DEFAULT TAG PARSER wiki-tags-default

let g:wiki_tag_parsers = [g:wiki#tags#orgmode_parser]

TEMPLATES wiki-templates

TEMPLATE FUNCTION CONTEXT wiki-templates-context

TEMPLATE FILE FORMAT wiki-templates-format

# {{wiki#template#case_title {name}}}
Created: {date} {time}

{{CustomUserFunc A new blog post}}

# Introduction

# Conclusion

function! CustomUserFunc(ctx, text) abort
  return a:ctx.name . ': ' . substitute(a:text, 'A new', 'An old', '')
endfunction

JOURNAL SUMMARIES wiki-templates-journal-summaries

<tables on top are ignored>

Topic 1
* List based summary
* With perhaps
  * sub lists

Topic 2
* List based summary
* With perhaps
  * sub lists

Topic 3
* Link to [[#Specific note ...]]

# Specific note (e.g. meeting note or similar)

Everything from this section header and on will be ignored.

ADVANCED CONFIGURATION GUIDE wiki-advanced-configuration

function! MyTestHandler(resolved, ...) abort
  echo a:resolved
endfunction

let g:wiki_link_schemes = {
      \ 'test': {
      \   'resolver': function('wiki#url#resolvers#wiki'),
      \   'handler': function('MyTestHandler'),
      \ }
      \}

vim.g.wiki_link_schemes = {
  test = {
    resolver = vim.fn["wiki#url#resolvers#wiki"],
    handler = function(x) print(vim.inspect(x)) end,
  }
}

" This is basically the same as wiki#url#resolvers#wiki, except we added
" a line to decode the encoded URL before we resolve the path.
function! MyWikiResolver(url) abort
  let l:url = deepcopy(a:url)

  let l:url.anchor = wiki#url#utils#extract_anchor(l:url.stripped)

  let l:path = split(l:url.stripped, '#', 1)[0]
  let l:path = wiki#url#utils#url_decode(l:path)
  let l:url.path = wiki#url#utils#resolve_path(l:path, l:url.origin)

  return l:url
endfunction

" Change the wiki scheme resolver
let g:wiki_link_schemes = {
      \ 'wiki': {
      \   'resolver': function('MyWikiResolver'),
      \ }
      \}

" Only change the url_transform - will keep other parts at default settings
let g:wiki_link_creation = {
      \ 'md': {
      \   'url_transform': { x -> wiki#url#utils#url_encode(x) },
      \ },
      \ 'wiki': {
      \   'url_transform': { x -> wiki#url#utils#url_encode(x) },
      \ },
      \}

vim.g.wiki_templates = {
  {
    match_re = [[\d\d\d\d-\d\d-\d\d]],
    source_filename = "/home/USER/wiki/.templates/daily.md"
  },
}

vim.g.wiki_templates = {
  {
    match_func = function(context)
      return context.path_wiki:find "%d%d%d%d/%d%d/%d%d"
    end,
    source_filename = "~/wiki/templates/daily.md"
  },
}