mirror of
https://github.com/neovim/neovim.git
synced 2024-12-23 20:55:18 -07:00
feat!: rewrite TOhtml in lua
Co-authored-by: wookayin <wookayin@gmail.com> Co-authored-by: clason <c.clason@uni-graz.at> Co-authored-by: Lewis Russell <me@lewisr.dev>
This commit is contained in:
altermo
Lewis Russell
parent
c538ec8522
commit
2f85bbe615
@ -1,951 +0,0 @@
|
||||
" Vim autoload file for the tohtml plugin.
|
||||
" Maintainer: Ben Fritz <fritzophrenic@gmail.com>
|
||||
" Last Change: 2023 Sep 03
|
||||
"
|
||||
" Additional contributors:
|
||||
"
|
||||
" Original by Bram Moolenaar <Bram@vim.org>
|
||||
" Diff2HTML() added by Christian Brabandt <cb@256bit.org>
|
||||
"
|
||||
" See Mercurial change logs for more!
|
||||
|
||||
" this file uses line continuations
|
||||
let s:cpo_sav = &cpo
|
||||
set cpo&vim
|
||||
|
||||
" Automatically find charsets from all encodings supported natively by Vim. With
|
||||
" the 8bit- and 2byte- prefixes, Vim can actually support more encodings than
|
||||
" this. Let the user specify these however since they won't be supported on
|
||||
" every system.
|
||||
"
|
||||
" Note, not all of Vim's supported encodings have a charset to use.
|
||||
"
|
||||
" Names in this list are from:
|
||||
" http://www.iana.org/assignments/character-sets
|
||||
" g:tohtml#encoding_to_charset: {{{
|
||||
let g:tohtml#encoding_to_charset = {
|
||||
\ 'latin1' : 'ISO-8859-1',
|
||||
\ 'iso-8859-2' : 'ISO-8859-2',
|
||||
\ 'iso-8859-3' : 'ISO-8859-3',
|
||||
\ 'iso-8859-4' : 'ISO-8859-4',
|
||||
\ 'iso-8859-5' : 'ISO-8859-5',
|
||||
\ 'iso-8859-6' : 'ISO-8859-6',
|
||||
\ 'iso-8859-7' : 'ISO-8859-7',
|
||||
\ 'iso-8859-8' : 'ISO-8859-8',
|
||||
\ 'iso-8859-9' : 'ISO-8859-9',
|
||||
\ 'iso-8859-10' : '',
|
||||
\ 'iso-8859-13' : 'ISO-8859-13',
|
||||
\ 'iso-8859-14' : '',
|
||||
\ 'iso-8859-15' : 'ISO-8859-15',
|
||||
\ 'koi8-r' : 'KOI8-R',
|
||||
\ 'koi8-u' : 'KOI8-U',
|
||||
\ 'macroman' : 'macintosh',
|
||||
\ 'cp437' : '',
|
||||
\ 'cp775' : '',
|
||||
\ 'cp850' : '',
|
||||
\ 'cp852' : '',
|
||||
\ 'cp855' : '',
|
||||
\ 'cp857' : '',
|
||||
\ 'cp860' : '',
|
||||
\ 'cp861' : '',
|
||||
\ 'cp862' : '',
|
||||
\ 'cp863' : '',
|
||||
\ 'cp865' : '',
|
||||
\ 'cp866' : 'IBM866',
|
||||
\ 'cp869' : '',
|
||||
\ 'cp874' : '',
|
||||
\ 'cp1250' : 'windows-1250',
|
||||
\ 'cp1251' : 'windows-1251',
|
||||
\ 'cp1253' : 'windows-1253',
|
||||
\ 'cp1254' : 'windows-1254',
|
||||
\ 'cp1255' : 'windows-1255',
|
||||
\ 'cp1256' : 'windows-1256',
|
||||
\ 'cp1257' : 'windows-1257',
|
||||
\ 'cp1258' : 'windows-1258',
|
||||
\ 'euc-jp' : 'EUC-JP',
|
||||
\ 'sjis' : 'Shift_JIS',
|
||||
\ 'cp932' : 'Shift_JIS',
|
||||
\ 'cp949' : '',
|
||||
\ 'euc-kr' : 'EUC-KR',
|
||||
\ 'cp936' : 'GBK',
|
||||
\ 'euc-cn' : 'GB2312',
|
||||
\ 'big5' : 'Big5',
|
||||
\ 'cp950' : 'Big5',
|
||||
\ 'utf-8' : 'UTF-8',
|
||||
\ 'ucs-2' : 'UTF-8',
|
||||
\ 'ucs-2le' : 'UTF-8',
|
||||
\ 'utf-16' : 'UTF-8',
|
||||
\ 'utf-16le' : 'UTF-8',
|
||||
\ 'ucs-4' : 'UTF-8',
|
||||
\ 'ucs-4le' : 'UTF-8',
|
||||
\ }
|
||||
lockvar g:tohtml#encoding_to_charset
|
||||
" Notes:
|
||||
" 1. All UCS/UTF are converted to UTF-8 because it is much better supported
|
||||
" 2. Any blank spaces are there because Vim supports it but at least one major
|
||||
" web browser does not according to http://wiki.whatwg.org/wiki/Web_Encodings.
|
||||
" }}}
|
||||
|
||||
" Only automatically find encodings supported natively by Vim, let the user
|
||||
" specify the encoding if it's not natively supported. This function is only
|
||||
" used when the user specifies the charset, they better know what they are
|
||||
" doing!
|
||||
"
|
||||
" Names in this list are from:
|
||||
" http://www.iana.org/assignments/character-sets
|
||||
" g:tohtml#charset_to_encoding: {{{
|
||||
let g:tohtml#charset_to_encoding = {
|
||||
\ 'iso_8859-1:1987' : 'latin1',
|
||||
\ 'iso-ir-100' : 'latin1',
|
||||
\ 'iso_8859-1' : 'latin1',
|
||||
\ 'iso-8859-1' : 'latin1',
|
||||
\ 'latin1' : 'latin1',
|
||||
\ 'l1' : 'latin1',
|
||||
\ 'ibm819' : 'latin1',
|
||||
\ 'cp819' : 'latin1',
|
||||
\ 'csisolatin1' : 'latin1',
|
||||
\ 'iso_8859-2:1987' : 'iso-8859-2',
|
||||
\ 'iso-ir-101' : 'iso-8859-2',
|
||||
\ 'iso_8859-2' : 'iso-8859-2',
|
||||
\ 'iso-8859-2' : 'iso-8859-2',
|
||||
\ 'latin2' : 'iso-8859-2',
|
||||
\ 'l2' : 'iso-8859-2',
|
||||
\ 'csisolatin2' : 'iso-8859-2',
|
||||
\ 'iso_8859-3:1988' : 'iso-8859-3',
|
||||
\ 'iso-ir-109' : 'iso-8859-3',
|
||||
\ 'iso_8859-3' : 'iso-8859-3',
|
||||
\ 'iso-8859-3' : 'iso-8859-3',
|
||||
\ 'latin3' : 'iso-8859-3',
|
||||
\ 'l3' : 'iso-8859-3',
|
||||
\ 'csisolatin3' : 'iso-8859-3',
|
||||
\ 'iso_8859-4:1988' : 'iso-8859-4',
|
||||
\ 'iso-ir-110' : 'iso-8859-4',
|
||||
\ 'iso_8859-4' : 'iso-8859-4',
|
||||
\ 'iso-8859-4' : 'iso-8859-4',
|
||||
\ 'latin4' : 'iso-8859-4',
|
||||
\ 'l4' : 'iso-8859-4',
|
||||
\ 'csisolatin4' : 'iso-8859-4',
|
||||
\ 'iso_8859-5:1988' : 'iso-8859-5',
|
||||
\ 'iso-ir-144' : 'iso-8859-5',
|
||||
\ 'iso_8859-5' : 'iso-8859-5',
|
||||
\ 'iso-8859-5' : 'iso-8859-5',
|
||||
\ 'cyrillic' : 'iso-8859-5',
|
||||
\ 'csisolatincyrillic' : 'iso-8859-5',
|
||||
\ 'iso_8859-6:1987' : 'iso-8859-6',
|
||||
\ 'iso-ir-127' : 'iso-8859-6',
|
||||
\ 'iso_8859-6' : 'iso-8859-6',
|
||||
\ 'iso-8859-6' : 'iso-8859-6',
|
||||
\ 'ecma-114' : 'iso-8859-6',
|
||||
\ 'asmo-708' : 'iso-8859-6',
|
||||
\ 'arabic' : 'iso-8859-6',
|
||||
\ 'csisolatinarabic' : 'iso-8859-6',
|
||||
\ 'iso_8859-7:1987' : 'iso-8859-7',
|
||||
\ 'iso-ir-126' : 'iso-8859-7',
|
||||
\ 'iso_8859-7' : 'iso-8859-7',
|
||||
\ 'iso-8859-7' : 'iso-8859-7',
|
||||
\ 'elot_928' : 'iso-8859-7',
|
||||
\ 'ecma-118' : 'iso-8859-7',
|
||||
\ 'greek' : 'iso-8859-7',
|
||||
\ 'greek8' : 'iso-8859-7',
|
||||
\ 'csisolatingreek' : 'iso-8859-7',
|
||||
\ 'iso_8859-8:1988' : 'iso-8859-8',
|
||||
\ 'iso-ir-138' : 'iso-8859-8',
|
||||
\ 'iso_8859-8' : 'iso-8859-8',
|
||||
\ 'iso-8859-8' : 'iso-8859-8',
|
||||
\ 'hebrew' : 'iso-8859-8',
|
||||
\ 'csisolatinhebrew' : 'iso-8859-8',
|
||||
\ 'iso_8859-9:1989' : 'iso-8859-9',
|
||||
\ 'iso-ir-148' : 'iso-8859-9',
|
||||
\ 'iso_8859-9' : 'iso-8859-9',
|
||||
\ 'iso-8859-9' : 'iso-8859-9',
|
||||
\ 'latin5' : 'iso-8859-9',
|
||||
\ 'l5' : 'iso-8859-9',
|
||||
\ 'csisolatin5' : 'iso-8859-9',
|
||||
\ 'iso-8859-10' : 'iso-8859-10',
|
||||
\ 'iso-ir-157' : 'iso-8859-10',
|
||||
\ 'l6' : 'iso-8859-10',
|
||||
\ 'iso_8859-10:1992' : 'iso-8859-10',
|
||||
\ 'csisolatin6' : 'iso-8859-10',
|
||||
\ 'latin6' : 'iso-8859-10',
|
||||
\ 'iso-8859-13' : 'iso-8859-13',
|
||||
\ 'iso-8859-14' : 'iso-8859-14',
|
||||
\ 'iso-ir-199' : 'iso-8859-14',
|
||||
\ 'iso_8859-14:1998' : 'iso-8859-14',
|
||||
\ 'iso_8859-14' : 'iso-8859-14',
|
||||
\ 'latin8' : 'iso-8859-14',
|
||||
\ 'iso-celtic' : 'iso-8859-14',
|
||||
\ 'l8' : 'iso-8859-14',
|
||||
\ 'iso-8859-15' : 'iso-8859-15',
|
||||
\ 'iso_8859-15' : 'iso-8859-15',
|
||||
\ 'latin-9' : 'iso-8859-15',
|
||||
\ 'koi8-r' : 'koi8-r',
|
||||
\ 'cskoi8r' : 'koi8-r',
|
||||
\ 'koi8-u' : 'koi8-u',
|
||||
\ 'macintosh' : 'macroman',
|
||||
\ 'mac' : 'macroman',
|
||||
\ 'csmacintosh' : 'macroman',
|
||||
\ 'ibm437' : 'cp437',
|
||||
\ 'cp437' : 'cp437',
|
||||
\ '437' : 'cp437',
|
||||
\ 'cspc8codepage437' : 'cp437',
|
||||
\ 'ibm775' : 'cp775',
|
||||
\ 'cp775' : 'cp775',
|
||||
\ 'cspc775baltic' : 'cp775',
|
||||
\ 'ibm850' : 'cp850',
|
||||
\ 'cp850' : 'cp850',
|
||||
\ '850' : 'cp850',
|
||||
\ 'cspc850multilingual' : 'cp850',
|
||||
\ 'ibm852' : 'cp852',
|
||||
\ 'cp852' : 'cp852',
|
||||
\ '852' : 'cp852',
|
||||
\ 'cspcp852' : 'cp852',
|
||||
\ 'ibm855' : 'cp855',
|
||||
\ 'cp855' : 'cp855',
|
||||
\ '855' : 'cp855',
|
||||
\ 'csibm855' : 'cp855',
|
||||
\ 'ibm857' : 'cp857',
|
||||
\ 'cp857' : 'cp857',
|
||||
\ '857' : 'cp857',
|
||||
\ 'csibm857' : 'cp857',
|
||||
\ 'ibm860' : 'cp860',
|
||||
\ 'cp860' : 'cp860',
|
||||
\ '860' : 'cp860',
|
||||
\ 'csibm860' : 'cp860',
|
||||
\ 'ibm861' : 'cp861',
|
||||
\ 'cp861' : 'cp861',
|
||||
\ '861' : 'cp861',
|
||||
\ 'cp-is' : 'cp861',
|
||||
\ 'csibm861' : 'cp861',
|
||||
\ 'ibm862' : 'cp862',
|
||||
\ 'cp862' : 'cp862',
|
||||
\ '862' : 'cp862',
|
||||
\ 'cspc862latinhebrew' : 'cp862',
|
||||
\ 'ibm863' : 'cp863',
|
||||
\ 'cp863' : 'cp863',
|
||||
\ '863' : 'cp863',
|
||||
\ 'csibm863' : 'cp863',
|
||||
\ 'ibm865' : 'cp865',
|
||||
\ 'cp865' : 'cp865',
|
||||
\ '865' : 'cp865',
|
||||
\ 'csibm865' : 'cp865',
|
||||
\ 'ibm866' : 'cp866',
|
||||
\ 'cp866' : 'cp866',
|
||||
\ '866' : 'cp866',
|
||||
\ 'csibm866' : 'cp866',
|
||||
\ 'ibm869' : 'cp869',
|
||||
\ 'cp869' : 'cp869',
|
||||
\ '869' : 'cp869',
|
||||
\ 'cp-gr' : 'cp869',
|
||||
\ 'csibm869' : 'cp869',
|
||||
\ 'windows-1250' : 'cp1250',
|
||||
\ 'windows-1251' : 'cp1251',
|
||||
\ 'windows-1253' : 'cp1253',
|
||||
\ 'windows-1254' : 'cp1254',
|
||||
\ 'windows-1255' : 'cp1255',
|
||||
\ 'windows-1256' : 'cp1256',
|
||||
\ 'windows-1257' : 'cp1257',
|
||||
\ 'windows-1258' : 'cp1258',
|
||||
\ 'extended_unix_code_packed_format_for_japanese' : 'euc-jp',
|
||||
\ 'cseucpkdfmtjapanese' : 'euc-jp',
|
||||
\ 'euc-jp' : 'euc-jp',
|
||||
\ 'shift_jis' : 'sjis',
|
||||
\ 'ms_kanji' : 'sjis',
|
||||
\ 'sjis' : 'sjis',
|
||||
\ 'csshiftjis' : 'sjis',
|
||||
\ 'ibm-thai' : 'cp874',
|
||||
\ 'csibmthai' : 'cp874',
|
||||
\ 'ks_c_5601-1987' : 'cp949',
|
||||
\ 'iso-ir-149' : 'cp949',
|
||||
\ 'ks_c_5601-1989' : 'cp949',
|
||||
\ 'ksc_5601' : 'cp949',
|
||||
\ 'korean' : 'cp949',
|
||||
\ 'csksc56011987' : 'cp949',
|
||||
\ 'euc-kr' : 'euc-kr',
|
||||
\ 'cseuckr' : 'euc-kr',
|
||||
\ 'gbk' : 'cp936',
|
||||
\ 'cp936' : 'cp936',
|
||||
\ 'ms936' : 'cp936',
|
||||
\ 'windows-936' : 'cp936',
|
||||
\ 'gb_2312-80' : 'euc-cn',
|
||||
\ 'iso-ir-58' : 'euc-cn',
|
||||
\ 'chinese' : 'euc-cn',
|
||||
\ 'csiso58gb231280' : 'euc-cn',
|
||||
\ 'big5' : 'big5',
|
||||
\ 'csbig5' : 'big5',
|
||||
\ 'utf-8' : 'utf-8',
|
||||
\ 'iso-10646-ucs-2' : 'ucs-2',
|
||||
\ 'csunicode' : 'ucs-2',
|
||||
\ 'utf-16' : 'utf-16',
|
||||
\ 'utf-16be' : 'utf-16',
|
||||
\ 'utf-16le' : 'utf-16le',
|
||||
\ 'utf-32' : 'ucs-4',
|
||||
\ 'utf-32be' : 'ucs-4',
|
||||
\ 'utf-32le' : 'ucs-4le',
|
||||
\ 'iso-10646-ucs-4' : 'ucs-4',
|
||||
\ 'csucs4' : 'ucs-4'
|
||||
\ }
|
||||
lockvar g:tohtml#charset_to_encoding
|
||||
"}}}
|
||||
|
||||
func! tohtml#Convert2HTML(line1, line2) "{{{
|
||||
let s:settings = tohtml#GetUserSettings()
|
||||
|
||||
if !&diff || s:settings.diff_one_file "{{{
|
||||
if a:line2 >= a:line1
|
||||
let g:html_start_line = a:line1
|
||||
let g:html_end_line = a:line2
|
||||
else
|
||||
let g:html_start_line = a:line2
|
||||
let g:html_end_line = a:line1
|
||||
endif
|
||||
runtime syntax/2html.vim "}}}
|
||||
else "{{{
|
||||
let win_list = []
|
||||
let buf_list = []
|
||||
windo if &diff | call add(win_list, winbufnr(0)) | endif
|
||||
let s:settings.whole_filler = 1
|
||||
let g:html_diff_win_num = 0
|
||||
for window in win_list
|
||||
" switch to the next buffer to convert
|
||||
exe ":" .. bufwinnr(window) .. "wincmd w"
|
||||
|
||||
" figure out whether current charset and encoding will work, if not
|
||||
" default to UTF-8
|
||||
if !exists('g:html_use_encoding') &&
|
||||
\ (((&l:fileencoding=='' || (&l:buftype!='' && &l:buftype!=?'help'))
|
||||
\ && &encoding!=?s:settings.vim_encoding)
|
||||
\ || &l:fileencoding!='' && &l:fileencoding!=?s:settings.vim_encoding)
|
||||
echohl WarningMsg
|
||||
echomsg "TOhtml: mismatched file encodings in Diff buffers, using UTF-8"
|
||||
echohl None
|
||||
let s:settings.vim_encoding = 'utf-8'
|
||||
let s:settings.encoding = 'UTF-8'
|
||||
endif
|
||||
|
||||
" set up for diff-mode conversion
|
||||
let g:html_start_line = 1
|
||||
let g:html_end_line = line('$')
|
||||
let g:html_diff_win_num += 1
|
||||
|
||||
" convert this file
|
||||
runtime syntax/2html.vim
|
||||
|
||||
" remember the HTML buffer for later combination
|
||||
call add(buf_list, bufnr('%'))
|
||||
endfor
|
||||
unlet g:html_diff_win_num
|
||||
call tohtml#Diff2HTML(win_list, buf_list)
|
||||
endif "}}}
|
||||
|
||||
unlet g:html_start_line
|
||||
unlet g:html_end_line
|
||||
unlet s:settings
|
||||
endfunc "}}}
|
||||
|
||||
func! tohtml#Diff2HTML(win_list, buf_list) "{{{
|
||||
let xml_line = ""
|
||||
let tag_close = '>'
|
||||
|
||||
let s:old_paste = &paste
|
||||
set paste
|
||||
let s:old_magic = &magic
|
||||
set magic
|
||||
|
||||
let html = []
|
||||
if !s:settings.no_doc
|
||||
if s:settings.use_xhtml
|
||||
if s:settings.encoding != ""
|
||||
let xml_line = "<?xml version=\"1.0\" encoding=\"" .. s:settings.encoding .. "\"?>"
|
||||
else
|
||||
let xml_line = "<?xml version=\"1.0\"?>"
|
||||
endif
|
||||
let tag_close = ' />'
|
||||
endif
|
||||
|
||||
let style = [s:settings.use_xhtml ? "" : '-->']
|
||||
let body_line = ''
|
||||
|
||||
let s:html5 = 0
|
||||
if s:settings.use_xhtml
|
||||
call add(html, xml_line)
|
||||
endif
|
||||
if s:settings.use_xhtml
|
||||
call add(html, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">")
|
||||
call add(html, '<html xmlns="http://www.w3.org/1999/xhtml">')
|
||||
elseif s:settings.use_css && !s:settings.no_pre
|
||||
call add(html, "<!DOCTYPE html>")
|
||||
call add(html, '<html>')
|
||||
let s:html5 = 1
|
||||
else
|
||||
call add(html, '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"')
|
||||
call add(html, ' "http://www.w3.org/TR/html4/loose.dtd">')
|
||||
call add(html, '<html>')
|
||||
endif
|
||||
call add(html, '<head>')
|
||||
|
||||
" include encoding as close to the top as possible, but only if not already
|
||||
" contained in XML information
|
||||
if s:settings.encoding != "" && !s:settings.use_xhtml
|
||||
if s:html5
|
||||
call add(html, '<meta charset="' .. s:settings.encoding .. '"' .. tag_close)
|
||||
else
|
||||
call add(html, "<meta http-equiv=\"content-type\" content=\"text/html; charset=" .. s:settings.encoding .. '"' .. tag_close)
|
||||
endif
|
||||
endif
|
||||
|
||||
call add(html, '<title>diff</title>')
|
||||
call add(html, '<meta name="Generator" content="Vim/'..v:version/100..'.'..v:version%100..'"'..tag_close)
|
||||
call add(html, '<meta name="plugin-version" content="'..g:loaded_2html_plugin..'"'..tag_close)
|
||||
call add(html, '<meta name="settings" content="'.
|
||||
\ join(filter(keys(s:settings),'s:settings[v:val]'),',').
|
||||
\ ',prevent_copy='..s:settings.prevent_copy.
|
||||
\ ',use_input_for_pc='..s:settings.use_input_for_pc.
|
||||
\ '"'..tag_close)
|
||||
call add(html, '<meta name="colorscheme" content="'.
|
||||
\ (exists('g:colors_name')
|
||||
\ ? g:colors_name
|
||||
\ : 'none').. '"'..tag_close)
|
||||
|
||||
call add(html, '</head>')
|
||||
let body_line_num = len(html)
|
||||
call add(html, '<body'..(s:settings.line_ids ? ' onload="JumpToLine();"' : '')..'>')
|
||||
endif
|
||||
call add(html, "<table "..(s:settings.use_css? "" : "border='1' width='100%' ").."id='vimCodeElement"..s:settings.id_suffix.."'>")
|
||||
|
||||
call add(html, '<tr>')
|
||||
for buf in a:win_list
|
||||
call add(html, '<th>'..bufname(buf)..'</th>')
|
||||
endfor
|
||||
call add(html, '</tr><tr>')
|
||||
|
||||
let diff_style_start = 0
|
||||
let insert_index = 0
|
||||
|
||||
for buf in a:buf_list
|
||||
let temp = []
|
||||
exe bufwinnr(buf) .. 'wincmd w'
|
||||
|
||||
" If text is folded because of user foldmethod settings, etc. we don't want
|
||||
" to act on everything in a fold by mistake.
|
||||
setlocal nofoldenable
|
||||
|
||||
" When not using CSS or when using xhtml, the <body> line can be important.
|
||||
" Assume it will be the same for all buffers and grab it from the first
|
||||
" buffer. Similarly, need to grab the body end line as well.
|
||||
if !s:settings.no_doc
|
||||
if body_line == ''
|
||||
1
|
||||
call search('<body')
|
||||
let body_line = getline('.')
|
||||
$
|
||||
call search('</body>', 'b')
|
||||
let s:body_end_line = getline('.')
|
||||
endif
|
||||
|
||||
" Grab the style information. Some of this will be duplicated so only insert
|
||||
" it if it's not already there. {{{
|
||||
1
|
||||
let style_start = search('^<style\( type="text/css"\)\?>')
|
||||
1
|
||||
let style_end = search('^</style>')
|
||||
if style_start > 0 && style_end > 0
|
||||
let buf_styles = getline(style_start + 1, style_end - 1)
|
||||
for a_style in buf_styles
|
||||
if index(style, a_style) == -1
|
||||
if diff_style_start == 0
|
||||
if a_style =~ '\<Diff\(Change\|Text\|Add\|Delete\)'
|
||||
let diff_style_start = len(style)-1
|
||||
endif
|
||||
endif
|
||||
call insert(style, a_style, insert_index)
|
||||
let insert_index += 1
|
||||
endif
|
||||
endfor
|
||||
endif " }}}
|
||||
|
||||
" everything new will get added before the diff styles so diff highlight
|
||||
" properly overrides normal highlight
|
||||
if diff_style_start != 0
|
||||
let insert_index = diff_style_start
|
||||
endif
|
||||
|
||||
" Delete those parts that are not needed so we can include the rest into the
|
||||
" resulting table.
|
||||
1,/^<body.*\%(\n<!--.*-->\_s\+.*id='oneCharWidth'.*\_s\+.*id='oneInputWidth'.*\_s\+.*id='oneEmWidth'\)\?\zs/d_
|
||||
$
|
||||
?</body>?,$d_
|
||||
elseif !s:settings.no_modeline
|
||||
" remove modeline from source files if it is included and we haven't deleted
|
||||
" due to removing html footer already
|
||||
$d
|
||||
endif
|
||||
let temp = getline(1,'$')
|
||||
" clean out id on the main content container because we already set it on
|
||||
" the table
|
||||
let temp[0] = substitute(temp[0], " id='vimCodeElement[^']*'", "", "")
|
||||
" undo deletion of start and end part
|
||||
" so we can later save the file as valid html
|
||||
" TODO: restore using grabbed lines if undolevel is 1?
|
||||
if !s:settings.no_doc
|
||||
normal! 2u
|
||||
elseif !s:settings.no_modeline
|
||||
normal! u
|
||||
endif
|
||||
if s:settings.use_css
|
||||
call add(html, '<td><div>')
|
||||
elseif s:settings.use_xhtml
|
||||
call add(html, '<td nowrap="nowrap" valign="top"><div>')
|
||||
else
|
||||
call add(html, '<td nowrap valign="top"><div>')
|
||||
endif
|
||||
let html += temp
|
||||
call add(html, '</div></td>')
|
||||
|
||||
" Close this buffer
|
||||
" TODO: the comment above says we're going to allow saving the file
|
||||
" later...but here we discard it?
|
||||
quit!
|
||||
endfor
|
||||
|
||||
if !s:settings.no_doc
|
||||
let html[body_line_num] = body_line
|
||||
endif
|
||||
|
||||
call add(html, '</tr>')
|
||||
call add(html, '</table>')
|
||||
if !s:settings.no_doc
|
||||
call add(html, s:body_end_line)
|
||||
call add(html, '</html>')
|
||||
endif
|
||||
|
||||
" The generated HTML is admittedly ugly and takes a LONG time to fold.
|
||||
" Make sure the user doesn't do syntax folding when loading a generated file,
|
||||
" using a modeline.
|
||||
if !s:settings.no_modeline
|
||||
call add(html, '<!-- vim: set foldmethod=manual : -->')
|
||||
endif
|
||||
|
||||
let i = 1
|
||||
let name = "Diff" .. (s:settings.use_xhtml ? ".xhtml" : ".html")
|
||||
" Find an unused file name if current file name is already in use
|
||||
while filereadable(name)
|
||||
let name = substitute(name, '\d*\.x\?html$', '', '') .. i .. '.' .. fnamemodify(copy(name), ":t:e")
|
||||
let i += 1
|
||||
endwhile
|
||||
|
||||
let s:ei_sav = &eventignore
|
||||
set eventignore+=FileType
|
||||
exe "topleft new " .. name
|
||||
let &eventignore=s:ei_sav
|
||||
unlet s:ei_sav
|
||||
|
||||
setlocal modifiable
|
||||
|
||||
" just in case some user autocmd creates content in the new buffer, make sure
|
||||
" it is empty before proceeding
|
||||
%d
|
||||
|
||||
" set the fileencoding to match the charset we'll be using
|
||||
let &l:fileencoding=s:settings.vim_encoding
|
||||
|
||||
" According to http://www.w3.org/TR/html4/charset.html#doc-char-set, the byte
|
||||
" order mark is highly recommend on the web when using multibyte encodings. But,
|
||||
" it is not a good idea to include it on UTF-8 files. Otherwise, let Vim
|
||||
" determine when it is actually inserted.
|
||||
if s:settings.vim_encoding == 'utf-8'
|
||||
setlocal nobomb
|
||||
else
|
||||
setlocal bomb
|
||||
endif
|
||||
|
||||
call append(0, html)
|
||||
|
||||
if !s:settings.no_doc
|
||||
if len(style) > 0
|
||||
1
|
||||
let style_start = search('^</head>')-1
|
||||
|
||||
" add required javascript in reverse order so we can just call append again
|
||||
" and again without adjusting {{{
|
||||
|
||||
let s:uses_script = s:settings.dynamic_folds || s:settings.line_ids
|
||||
|
||||
" insert script closing tag if needed
|
||||
if s:uses_script
|
||||
call append(style_start, [
|
||||
\ '',
|
||||
\ s:settings.use_xhtml ? '//]]>' : '-->',
|
||||
\ "</script>"
|
||||
\ ])
|
||||
endif
|
||||
|
||||
" insert javascript to get IDs from line numbers, and to open a fold before
|
||||
" jumping to any lines contained therein
|
||||
if s:settings.line_ids
|
||||
call append(style_start, [
|
||||
\ " /* Always jump to new location even if the line was hidden inside a fold, or",
|
||||
\ " * we corrected the raw number to a line ID.",
|
||||
\ " */",
|
||||
\ " if (lineElem) {",
|
||||
\ " lineElem.scrollIntoView(true);",
|
||||
\ " }",
|
||||
\ " return true;",
|
||||
\ "}",
|
||||
\ "if ('onhashchange' in window) {",
|
||||
\ " window.onhashchange = JumpToLine;",
|
||||
\ "}"
|
||||
\ ])
|
||||
|
||||
if s:settings.dynamic_folds
|
||||
call append(style_start, [
|
||||
\ "",
|
||||
\ " /* navigate upwards in the DOM tree to open all folds containing the line */",
|
||||
\ " var node = lineElem;",
|
||||
\ " while (node && node.id != 'vimCodeElement"..s:settings.id_suffix.."')",
|
||||
\ " {",
|
||||
\ " if (node.className == 'closed-fold')",
|
||||
\ " {",
|
||||
\ " /* toggle open the fold ID (remove window ID) */",
|
||||
\ " toggleFold(node.id.substr(4));",
|
||||
\ " }",
|
||||
\ " node = node.parentNode;",
|
||||
\ " }",
|
||||
\ ])
|
||||
endif
|
||||
endif
|
||||
|
||||
if s:settings.line_ids
|
||||
call append(style_start, [
|
||||
\ "",
|
||||
\ "/* function to open any folds containing a jumped-to line before jumping to it */",
|
||||
\ "function JumpToLine()",
|
||||
\ "{",
|
||||
\ " var lineNum;",
|
||||
\ " lineNum = window.location.hash;",
|
||||
\ " lineNum = lineNum.substr(1); /* strip off '#' */",
|
||||
\ "",
|
||||
\ " if (lineNum.indexOf('L') == -1) {",
|
||||
\ " lineNum = 'L'+lineNum;",
|
||||
\ " }",
|
||||
\ " if (lineNum.indexOf('W') == -1) {",
|
||||
\ " lineNum = 'W1'+lineNum;",
|
||||
\ " }",
|
||||
\ " var lineElem = document.getElementById(lineNum);"
|
||||
\ ])
|
||||
endif
|
||||
|
||||
" Insert javascript to toggle matching folds open and closed in all windows,
|
||||
" if dynamic folding is active.
|
||||
if s:settings.dynamic_folds
|
||||
call append(style_start, [
|
||||
\ " function toggleFold(objID)",
|
||||
\ " {",
|
||||
\ " for (win_num = 1; win_num <= "..len(a:buf_list).."; win_num++)",
|
||||
\ " {",
|
||||
\ " var fold;",
|
||||
\ ' fold = document.getElementById("win"+win_num+objID);',
|
||||
\ " if(fold.className == 'closed-fold')",
|
||||
\ " {",
|
||||
\ " fold.className = 'open-fold';",
|
||||
\ " }",
|
||||
\ " else if (fold.className == 'open-fold')",
|
||||
\ " {",
|
||||
\ " fold.className = 'closed-fold';",
|
||||
\ " }",
|
||||
\ " }",
|
||||
\ " }",
|
||||
\ ])
|
||||
endif
|
||||
|
||||
if s:uses_script
|
||||
" insert script tag if needed
|
||||
call append(style_start, [
|
||||
\ "<script" .. (s:html5 ? "" : " type='text/javascript'") .. ">",
|
||||
\ s:settings.use_xhtml ? '//<![CDATA[' : "<!--"])
|
||||
endif
|
||||
|
||||
" Insert styles from all the generated html documents and additional styles
|
||||
" for the table-based layout of the side-by-side diff. The diff should take
|
||||
" up the full browser window (but not more), and be static in size,
|
||||
" horizontally scrollable when the lines are too long. Otherwise, the diff
|
||||
" is pretty useless for really long lines. {{{
|
||||
if s:settings.use_css
|
||||
call append(style_start,
|
||||
\ ['<style' .. (s:html5 ? '' : 'type="text/css"') .. '>']+
|
||||
\ style+
|
||||
\ [ s:settings.use_xhtml ? '' : '<!--',
|
||||
\ 'table { table-layout: fixed; }',
|
||||
\ 'html, body, table, tbody { width: 100%; margin: 0; padding: 0; }',
|
||||
\ 'table, td, th { border: 1px solid; }',
|
||||
\ 'td { vertical-align: top; }',
|
||||
\ 'th, td { width: '..printf("%.1f",100.0/len(a:win_list))..'%; }',
|
||||
\ 'td div { overflow: auto; }',
|
||||
\ s:settings.use_xhtml ? '' : '-->',
|
||||
\ '</style>'
|
||||
\])
|
||||
endif "}}}
|
||||
endif
|
||||
endif
|
||||
|
||||
let &paste = s:old_paste
|
||||
let &magic = s:old_magic
|
||||
endfunc "}}}
|
||||
|
||||
" Gets a single user option and sets it in the passed-in Dict, or gives it the
|
||||
" default value if the option doesn't actually exist.
|
||||
func! tohtml#GetOption(settings, option, default) "{{{
|
||||
if exists('g:html_'..a:option)
|
||||
let a:settings[a:option] = g:html_{a:option}
|
||||
else
|
||||
let a:settings[a:option] = a:default
|
||||
endif
|
||||
endfunc "}}}
|
||||
|
||||
" returns a Dict containing the values of all user options for 2html, including
|
||||
" default values for those not given an explicit value by the user. Discards the
|
||||
" html_ prefix of the option for nicer looking code.
|
||||
func! tohtml#GetUserSettings() "{{{
|
||||
if exists('s:settings')
|
||||
" just restore the known options if we've already retrieved them
|
||||
return s:settings
|
||||
else
|
||||
" otherwise figure out which options are set
|
||||
let user_settings = {}
|
||||
|
||||
" Define the correct option if the old option name exists and we haven't
|
||||
" already defined the correct one.
|
||||
if exists('g:use_xhtml') && !exists("g:html_use_xhtml")
|
||||
echohl WarningMsg
|
||||
echomsg "Warning: g:use_xhtml is deprecated, use g:html_use_xhtml"
|
||||
echohl None
|
||||
let g:html_use_xhtml = g:use_xhtml
|
||||
endif
|
||||
|
||||
" get current option settings with appropriate defaults {{{
|
||||
call tohtml#GetOption(user_settings, 'no_progress', !has("statusline") )
|
||||
call tohtml#GetOption(user_settings, 'diff_one_file', 0 )
|
||||
call tohtml#GetOption(user_settings, 'number_lines', &number )
|
||||
call tohtml#GetOption(user_settings, 'pre_wrap', &wrap )
|
||||
call tohtml#GetOption(user_settings, 'use_css', 1 )
|
||||
call tohtml#GetOption(user_settings, 'ignore_conceal', 0 )
|
||||
call tohtml#GetOption(user_settings, 'ignore_folding', 0 )
|
||||
call tohtml#GetOption(user_settings, 'dynamic_folds', 0 )
|
||||
call tohtml#GetOption(user_settings, 'no_foldcolumn', user_settings.ignore_folding)
|
||||
call tohtml#GetOption(user_settings, 'hover_unfold', 0 )
|
||||
call tohtml#GetOption(user_settings, 'no_pre', 0 )
|
||||
call tohtml#GetOption(user_settings, 'no_doc', 0 )
|
||||
call tohtml#GetOption(user_settings, 'no_links', 0 )
|
||||
call tohtml#GetOption(user_settings, 'no_modeline', 0 )
|
||||
call tohtml#GetOption(user_settings, 'no_invalid', 0 )
|
||||
call tohtml#GetOption(user_settings, 'whole_filler', 0 )
|
||||
call tohtml#GetOption(user_settings, 'use_xhtml', 0 )
|
||||
call tohtml#GetOption(user_settings, 'line_ids', user_settings.number_lines )
|
||||
call tohtml#GetOption(user_settings, 'use_input_for_pc', 'none')
|
||||
" }}}
|
||||
|
||||
" override those settings that need it {{{
|
||||
|
||||
" hover opening implies dynamic folding
|
||||
if user_settings.hover_unfold
|
||||
let user_settings.dynamic_folds = 1
|
||||
endif
|
||||
|
||||
" ignore folding overrides dynamic folding
|
||||
if user_settings.ignore_folding && user_settings.dynamic_folds
|
||||
let user_settings.dynamic_folds = 0
|
||||
let user_settings.hover_unfold = 0
|
||||
endif
|
||||
|
||||
" dynamic folding with no foldcolumn implies hover opens
|
||||
if user_settings.dynamic_folds && user_settings.no_foldcolumn
|
||||
let user_settings.hover_unfold = 1
|
||||
endif
|
||||
|
||||
" dynamic folding implies css
|
||||
if user_settings.dynamic_folds
|
||||
let user_settings.use_css = 1
|
||||
else
|
||||
let user_settings.no_foldcolumn = 1 " won't do anything but for consistency and for the test suite
|
||||
endif
|
||||
|
||||
" if we're not using CSS we cannot use a pre section because <font> tags
|
||||
" aren't allowed inside a <pre> block
|
||||
if !user_settings.use_css
|
||||
let user_settings.no_pre = 1
|
||||
endif
|
||||
|
||||
" pre_wrap doesn't do anything if not using pre or not using CSS
|
||||
if user_settings.no_pre || !user_settings.use_css
|
||||
let user_settings.pre_wrap = 0
|
||||
endif
|
||||
"}}}
|
||||
|
||||
" set up expand_tabs option after all the overrides so we know the
|
||||
" appropriate defaults {{{
|
||||
if user_settings.no_pre == 0
|
||||
call tohtml#GetOption(user_settings,
|
||||
\ 'expand_tabs',
|
||||
\ &expandtab || &ts != 8 || (exists("+vts") && &vts != '') || user_settings.number_lines ||
|
||||
\ (user_settings.dynamic_folds && !user_settings.no_foldcolumn))
|
||||
else
|
||||
let user_settings.expand_tabs = 1
|
||||
endif
|
||||
" }}}
|
||||
|
||||
" textual options
|
||||
if exists("g:html_use_encoding") "{{{
|
||||
" user specified the desired MIME charset, figure out proper
|
||||
" 'fileencoding' from it or warn the user if we cannot
|
||||
let user_settings.encoding = g:html_use_encoding
|
||||
let user_settings.vim_encoding = tohtml#EncodingFromCharset(g:html_use_encoding)
|
||||
if user_settings.vim_encoding == ''
|
||||
echohl WarningMsg
|
||||
echomsg "TOhtml: file encoding for"
|
||||
\ g:html_use_encoding
|
||||
\ "unknown, please set 'fileencoding'"
|
||||
echohl None
|
||||
endif
|
||||
else
|
||||
" Figure out proper MIME charset from 'fileencoding' if possible
|
||||
if &l:fileencoding != ''
|
||||
" If the buffer is not a "normal" type, the 'fileencoding' value may not
|
||||
" be trusted; since the buffer should not be written the fileencoding is
|
||||
" not intended to be used.
|
||||
if &l:buftype=='' || &l:buftype==?'help'
|
||||
let user_settings.vim_encoding = &l:fileencoding
|
||||
call tohtml#CharsetFromEncoding(user_settings)
|
||||
else
|
||||
let user_settings.encoding = '' " trigger detection using &encoding
|
||||
endif
|
||||
endif
|
||||
|
||||
" else from 'encoding' if possible
|
||||
if &l:fileencoding == '' || user_settings.encoding == ''
|
||||
let user_settings.vim_encoding = &encoding
|
||||
call tohtml#CharsetFromEncoding(user_settings)
|
||||
endif
|
||||
|
||||
" else default to UTF-8 and warn user
|
||||
if user_settings.encoding == ''
|
||||
let user_settings.vim_encoding = 'utf-8'
|
||||
let user_settings.encoding = 'UTF-8'
|
||||
echohl WarningMsg
|
||||
echomsg "TOhtml: couldn't determine MIME charset, using UTF-8"
|
||||
echohl None
|
||||
endif
|
||||
endif "}}}
|
||||
|
||||
" Default to making nothing uncopyable, because we default to
|
||||
" not-standards way of doing things, and also because Microsoft Word and
|
||||
" others paste the <input> elements anyway.
|
||||
"
|
||||
" html_prevent_copy only has an effect when using CSS.
|
||||
"
|
||||
" All options:
|
||||
" f - fold column
|
||||
" n - line numbers (also within fold text)
|
||||
" t - fold text
|
||||
" d - diff filler
|
||||
" c - concealed text (reserved future)
|
||||
" l - listchars (reserved possible future)
|
||||
" s - signs (reserved possible future)
|
||||
"
|
||||
" Normal text is always selectable.
|
||||
let user_settings.prevent_copy = ""
|
||||
if user_settings.use_css
|
||||
if exists("g:html_prevent_copy")
|
||||
if user_settings.dynamic_folds && !user_settings.no_foldcolumn && g:html_prevent_copy =~# 'f'
|
||||
let user_settings.prevent_copy ..= 'f'
|
||||
endif
|
||||
if user_settings.number_lines && g:html_prevent_copy =~# 'n'
|
||||
let user_settings.prevent_copy ..= 'n'
|
||||
endif
|
||||
if &diff && g:html_prevent_copy =~# 'd'
|
||||
let user_settings.prevent_copy ..= 'd'
|
||||
endif
|
||||
if !user_settings.ignore_folding && g:html_prevent_copy =~# 't'
|
||||
let user_settings.prevent_copy ..= 't'
|
||||
endif
|
||||
else
|
||||
let user_settings.prevent_copy = ""
|
||||
endif
|
||||
endif
|
||||
if empty(user_settings.prevent_copy)
|
||||
let user_settings.no_invalid = 0
|
||||
endif
|
||||
|
||||
" enforce valid values for use_input_for_pc
|
||||
if user_settings.use_input_for_pc !~# 'fallback\|none\|all'
|
||||
let user_settings.use_input_for_pc = 'none'
|
||||
echohl WarningMsg
|
||||
echomsg '2html: "' .. g:html_use_input_for_pc .. '" is not valid for g:html_use_input_for_pc'
|
||||
echomsg '2html: defaulting to "' .. user_settings.use_input_for_pc .. '"'
|
||||
echohl None
|
||||
sleep 3
|
||||
endif
|
||||
|
||||
if exists('g:html_id_expr')
|
||||
let user_settings.id_suffix = eval(g:html_id_expr)
|
||||
if user_settings.id_suffix !~ '^[-_:.A-Za-z0-9]*$'
|
||||
echohl WarningMsg
|
||||
echomsg '2html: g:html_id_expr evaluated to invalid string for HTML id attributes'
|
||||
echomsg '2html: Omitting user-specified suffix'
|
||||
echohl None
|
||||
sleep 3
|
||||
let user_settings.id_suffix=""
|
||||
endif
|
||||
else
|
||||
let user_settings.id_suffix=""
|
||||
endif
|
||||
|
||||
" TODO: font
|
||||
|
||||
return user_settings
|
||||
endif
|
||||
endfunc "}}}
|
||||
|
||||
" get the proper HTML charset name from a Vim encoding option.
|
||||
function! tohtml#CharsetFromEncoding(settings) "{{{
|
||||
let l:vim_encoding = a:settings.vim_encoding
|
||||
if exists('g:html_charset_override') && has_key(g:html_charset_override, l:vim_encoding)
|
||||
let a:settings.encoding = g:html_charset_override[l:vim_encoding]
|
||||
else
|
||||
if l:vim_encoding =~ '^8bit\|^2byte'
|
||||
" 8bit- and 2byte- prefixes are to indicate encodings available on the
|
||||
" system that Vim will convert with iconv(), look up just the encoding name,
|
||||
" not Vim's prefix.
|
||||
let l:vim_encoding = substitute(l:vim_encoding, '^8bit-\|^2byte-', '', '')
|
||||
endif
|
||||
if has_key(g:tohtml#encoding_to_charset, l:vim_encoding)
|
||||
let a:settings.encoding = g:tohtml#encoding_to_charset[l:vim_encoding]
|
||||
else
|
||||
let a:settings.encoding = ""
|
||||
endif
|
||||
endif
|
||||
if a:settings.encoding != ""
|
||||
let l:vim_encoding = tohtml#EncodingFromCharset(a:settings.encoding)
|
||||
if l:vim_encoding != ""
|
||||
" if the Vim encoding to HTML encoding conversion is set up (by default or
|
||||
" by the user) to convert to a different encoding, we need to also change
|
||||
" the Vim encoding of the new buffer
|
||||
let a:settings.vim_encoding = l:vim_encoding
|
||||
endif
|
||||
endif
|
||||
endfun "}}}
|
||||
|
||||
" Get the proper Vim encoding option setting from an HTML charset name.
|
||||
function! tohtml#EncodingFromCharset(encoding) "{{{
|
||||
if exists('g:html_encoding_override') && has_key(g:html_encoding_override, a:encoding)
|
||||
return g:html_encoding_override[a:encoding]
|
||||
elseif has_key(g:tohtml#charset_to_encoding, tolower(a:encoding))
|
||||
return g:tohtml#charset_to_encoding[tolower(a:encoding)]
|
||||
else
|
||||
return ""
|
||||
endif
|
||||
endfun "}}}
|
||||
|
||||
let &cpo = s:cpo_sav
|
||||
unlet s:cpo_sav
|
||||
|
||||
" Make sure any patches will probably use consistent indent
|
||||
" vim: ts=8 sw=2 sts=2 noet fdm=marker
|
||||
@ -4363,4 +4363,35 @@ vim.text.hexencode({str}) *vim.text.hexencode()*
|
||||
(`string`) Hex encoded string
|
||||
|
||||
|
||||
==============================================================================
|
||||
Lua module: tohtml *vim.tohtml*
|
||||
|
||||
|
||||
:TOhtml {file} *:TOhtml*
|
||||
Converts the buffer shown in the current window to HTML, opens the generated
|
||||
HTML in a new split window, and saves its contents to {file}. If {file} is not
|
||||
given, a temporary file (created by |tempname()|) is used.
|
||||
|
||||
|
||||
tohtml.tohtml({winid}, {opt}) *tohtml.tohtml.tohtml()*
|
||||
Converts the buffer shown in the window {winid} to HTML and returns the
|
||||
output as a list of string.
|
||||
|
||||
Parameters: ~
|
||||
• {winid} (`integer?`) Window to convert (defaults to current window)
|
||||
• {opt} (`table?`) Optional parameters.
|
||||
• title (string): Title tag to set in the generated HTML code
|
||||
(defaults to buffer name)
|
||||
• number_lines (boolean): Show line numbers (defaults to
|
||||
`false`)
|
||||
• font (string|string[]): Fonts to use (defaults to
|
||||
`guifont`)
|
||||
• width (integer) Width used for items which are either right
|
||||
aligned or repeat a character infinitely (defaults to
|
||||
'textwidth' if non-zero or window width otherwise)
|
||||
|
||||
Return: ~
|
||||
(`string[]`)
|
||||
|
||||
|
||||
vim:tw=78:ts=8:sw=4:sts=4:et:ft=help:norl:
|
||||
|
||||
@ -134,6 +134,9 @@ The following changes may require adaptations in user config or plugins.
|
||||
If necessary, the respective capability can be
|
||||
removed when calling |vim.lsp.protocol.make_client_capabilities()|.
|
||||
|
||||
• |:TOhtml| has been rewritten in Lua to support Neovim-specific decorations,
|
||||
and many options have been removed.
|
||||
|
||||
==============================================================================
|
||||
BREAKING CHANGES IN HEAD *news-breaking-dev*
|
||||
|
||||
|
||||
@ -341,443 +341,11 @@ Upon loading a file, Vim finds the relevant syntax file as follows:
|
||||
syntax.
|
||||
|
||||
==============================================================================
|
||||
4. Conversion to HTML *2html.vim* *convert-to-HTML*
|
||||
4. Conversion to HTML *convert-to-HTML* *2html.vim*
|
||||
|
||||
2html is not a syntax file itself, but a script that converts the current
|
||||
window into HTML. Vim opens a new window in which it builds the HTML file.
|
||||
The old to html converter has ben replaced by a Lua version and the
|
||||
documentation has been moved to |:TOhtml|.
|
||||
|
||||
After you save the resulting file, you can view it with any browser. The
|
||||
colors should be exactly the same as you see them in Vim. With
|
||||
|g:html_line_ids| you can jump to specific lines by adding (for example) #L123
|
||||
or #123 to the end of the URL in your browser's address bar. And with
|
||||
|g:html_dynamic_folds| enabled, you can show or hide the text that is folded
|
||||
in Vim.
|
||||
|
||||
You are not supposed to set the 'filetype' or 'syntax' option to "2html"!
|
||||
Source the script to convert the current file: >
|
||||
|
||||
:runtime! syntax/2html.vim
|
||||
<
|
||||
Many variables affect the output of 2html.vim; see below. Any of the on/off
|
||||
options listed below can be enabled or disabled by setting them explicitly to
|
||||
the desired value, or restored to their default by removing the variable using
|
||||
|:unlet|.
|
||||
|
||||
Remarks:
|
||||
- Some truly ancient browsers may not show the background colors.
|
||||
- From most browsers you can also print the file (in color)!
|
||||
|
||||
Here is an example how to run the script over all .c and .h files from a
|
||||
Unix shell: >
|
||||
for f in *.[ch]; do gvim -f +"syn on" +"run! syntax/2html.vim" +"wq" +"q" $f; done
|
||||
<
|
||||
*g:html_start_line* *g:html_end_line*
|
||||
To restrict the conversion to a range of lines, use a range with the |:TOhtml|
|
||||
command below, or set "g:html_start_line" and "g:html_end_line" to the first
|
||||
and last line to be converted. Example, using the last set Visual area: >
|
||||
|
||||
:let g:html_start_line = line("'<")
|
||||
:let g:html_end_line = line("'>")
|
||||
:runtime! syntax/2html.vim
|
||||
<
|
||||
*:TOhtml*
|
||||
:[range]TOhtml The ":TOhtml" command is defined in a standard plugin.
|
||||
This command will source |2html.vim| for you. When a
|
||||
range is given, this command sets |g:html_start_line|
|
||||
and |g:html_end_line| to the start and end of the
|
||||
range, respectively. Default range is the entire
|
||||
buffer.
|
||||
|
||||
If the current window is part of a |diff|, unless
|
||||
|g:html_diff_one_file| is set, :TOhtml will convert
|
||||
all windows which are part of the diff in the current
|
||||
tab and place them side-by-side in a <table> element
|
||||
in the generated HTML. With |g:html_line_ids| you can
|
||||
jump to lines in specific windows with (for example)
|
||||
#W1L42 for line 42 in the first diffed window, or
|
||||
#W3L87 for line 87 in the third.
|
||||
|
||||
Examples: >
|
||||
|
||||
:10,40TOhtml " convert lines 10-40 to html
|
||||
:'<,'>TOhtml " convert current/last visual selection
|
||||
:TOhtml " convert entire buffer
|
||||
<
|
||||
*g:html_diff_one_file*
|
||||
Default: 0.
|
||||
When 0, and using |:TOhtml| all windows involved in a |diff| in the current tab
|
||||
page are converted to HTML and placed side-by-side in a <table> element. When
|
||||
1, only the current buffer is converted.
|
||||
Example: >
|
||||
|
||||
let g:html_diff_one_file = 1
|
||||
<
|
||||
*g:html_whole_filler*
|
||||
Default: 0.
|
||||
When 0, if |g:html_diff_one_file| is 1, a sequence of more than 3 filler lines
|
||||
is displayed as three lines with the middle line mentioning the total number
|
||||
of inserted lines.
|
||||
When 1, always display all inserted lines as if |g:html_diff_one_file| were
|
||||
not set.
|
||||
>
|
||||
:let g:html_whole_filler = 1
|
||||
<
|
||||
*TOhtml-performance* *g:html_no_progress*
|
||||
Default: 0.
|
||||
When 0, display a progress bar in the statusline for each major step in the
|
||||
2html.vim conversion process.
|
||||
When 1, do not display the progress bar. This offers a minor speed improvement
|
||||
but you won't have any idea how much longer the conversion might take; for big
|
||||
files it can take a long time!
|
||||
Example: >
|
||||
|
||||
let g:html_no_progress = 1
|
||||
<
|
||||
You can obtain better performance improvements by also instructing Vim to not
|
||||
run interactively, so that too much time is not taken to redraw as the script
|
||||
moves through the buffer, switches windows, and the like: >
|
||||
|
||||
vim -E -s -c "let g:html_no_progress=1" -c "syntax on" -c "set ft=c" -c "runtime syntax/2html.vim" -cwqa myfile.c
|
||||
<
|
||||
Note that the -s flag prevents loading your vimrc and any plugins, so you
|
||||
need to explicitly source/enable anything that will affect the HTML
|
||||
conversion. See |-E| and |-s-ex| for details. It is probably best to create a
|
||||
script to replace all the -c commands and use it with the -u flag instead of
|
||||
specifying each command separately.
|
||||
|
||||
*hl-TOhtmlProgress* *TOhtml-progress-color*
|
||||
When displayed, the progress bar will show colored boxes along the statusline
|
||||
as the HTML conversion proceeds. By default, the background color as the
|
||||
current "DiffDelete" highlight group is used. If "DiffDelete" and "StatusLine"
|
||||
have the same background color, TOhtml will automatically adjust the color to
|
||||
differ. If you do not like the automatically selected colors, you can define
|
||||
your own highlight colors for the progress bar. Example: >
|
||||
|
||||
hi TOhtmlProgress guifg=#c0ffee ctermbg=7
|
||||
<
|
||||
*g:html_number_lines*
|
||||
Default: Current 'number' setting.
|
||||
When 0, buffer text is displayed in the generated HTML without line numbering.
|
||||
When 1, a column of line numbers is added to the generated HTML with the same
|
||||
highlighting as the line number column in Vim (|hl-LineNr|).
|
||||
Force line numbers even if 'number' is not set: >
|
||||
:let g:html_number_lines = 1
|
||||
Force to omit the line numbers: >
|
||||
:let g:html_number_lines = 0
|
||||
Go back to the default to use 'number' by deleting the variable: >
|
||||
:unlet g:html_number_lines
|
||||
<
|
||||
*g:html_line_ids*
|
||||
Default: 1 if |g:html_number_lines| is set, 0 otherwise.
|
||||
When 1, adds an HTML id attribute to each line number, or to an empty <span>
|
||||
inserted for that purpose if no line numbers are shown. This ID attribute
|
||||
takes the form of L123 for single-buffer HTML pages, or W2L123 for diff-view
|
||||
pages, and is used to jump to a specific line (in a specific window of a diff
|
||||
view). Javascript is inserted to open any closed dynamic folds
|
||||
(|g:html_dynamic_folds|) containing the specified line before jumping. The
|
||||
javascript also allows omitting the window ID in the url, and the leading L.
|
||||
For example: >
|
||||
|
||||
page.html#L123 jumps to line 123 in a single-buffer file
|
||||
page.html#123 does the same
|
||||
|
||||
diff.html#W1L42 jumps to line 42 in the first window in a diff
|
||||
diff.html#42 does the same
|
||||
<
|
||||
*g:html_use_css*
|
||||
Default: 1.
|
||||
When 1, generate valid HTML 5 markup with CSS styling, supported in all modern
|
||||
browsers and many old browsers.
|
||||
When 0, generate <font> tags and similar outdated markup. This is not
|
||||
recommended but it may work better in really old browsers, email clients,
|
||||
forum posts, and similar situations where basic CSS support is unavailable.
|
||||
Example: >
|
||||
:let g:html_use_css = 0
|
||||
<
|
||||
*g:html_ignore_conceal*
|
||||
Default: 0.
|
||||
When 0, concealed text is removed from the HTML and replaced with a character
|
||||
from |:syn-cchar| or 'listchars' as appropriate, depending on the current
|
||||
value of 'conceallevel'.
|
||||
When 1, include all text from the buffer in the generated HTML, even if it is
|
||||
|conceal|ed.
|
||||
|
||||
Either of the following commands will ensure that all text in the buffer is
|
||||
included in the generated HTML (unless it is folded): >
|
||||
:let g:html_ignore_conceal = 1
|
||||
:setl conceallevel=0
|
||||
<
|
||||
*g:html_ignore_folding*
|
||||
Default: 0.
|
||||
When 0, text in a closed fold is replaced by the text shown for the fold in
|
||||
Vim (|fold-foldtext|). See |g:html_dynamic_folds| if you also want to allow
|
||||
the user to expand the fold as in Vim to see the text inside.
|
||||
When 1, include all text from the buffer in the generated HTML; whether the
|
||||
text is in a fold has no impact at all. |g:html_dynamic_folds| has no effect.
|
||||
|
||||
Either of these commands will ensure that all text in the buffer is included
|
||||
in the generated HTML (unless it is concealed): >
|
||||
zR
|
||||
:let g:html_ignore_folding = 1
|
||||
<
|
||||
*g:html_dynamic_folds*
|
||||
Default: 0.
|
||||
When 0, text in a closed fold is not included at all in the generated HTML.
|
||||
When 1, generate javascript to open a fold and show the text within, just like
|
||||
in Vim.
|
||||
|
||||
Setting this variable to 1 causes 2html.vim to always use CSS for styling,
|
||||
regardless of what |g:html_use_css| is set to.
|
||||
|
||||
This variable is ignored when |g:html_ignore_folding| is set.
|
||||
>
|
||||
:let g:html_dynamic_folds = 1
|
||||
<
|
||||
*g:html_no_foldcolumn*
|
||||
Default: 0.
|
||||
When 0, if |g:html_dynamic_folds| is 1, generate a column of text similar to
|
||||
Vim's foldcolumn (|fold-foldcolumn|) the user can click on to toggle folds
|
||||
open or closed. The minimum width of the generated text column is the current
|
||||
'foldcolumn' setting.
|
||||
When 1, do not generate this column; instead, hovering the mouse cursor over
|
||||
folded text will open the fold as if |g:html_hover_unfold| were set.
|
||||
>
|
||||
:let g:html_no_foldcolumn = 1
|
||||
<
|
||||
*TOhtml-uncopyable-text* *g:html_prevent_copy*
|
||||
Default: Empty string.
|
||||
This option prevents certain regions of the generated HTML from being copied,
|
||||
when you select all text in document rendered in a browser and copy it. Useful
|
||||
for allowing users to copy-paste only the source text even if a fold column or
|
||||
line numbers are shown in the generated content. Specify regions to be
|
||||
affected in this way as follows:
|
||||
f: fold column
|
||||
n: line numbers (also within fold text)
|
||||
t: fold text
|
||||
d: diff filler
|
||||
|
||||
Example, to make the fold column and line numbers uncopyable: >
|
||||
:let g:html_prevent_copy = "fn"
|
||||
<
|
||||
The method used to prevent copying in the generated page depends on the value
|
||||
of |g:html_use_input_for_pc|.
|
||||
|
||||
*g:html_use_input_for_pc*
|
||||
Default: "none"
|
||||
If |g:html_prevent_copy| is non-empty, then:
|
||||
|
||||
When "all", read-only <input> elements are used in place of normal text for
|
||||
uncopyable regions. In some browsers, especially older browsers, after
|
||||
selecting an entire page and copying the selection, the <input> tags are not
|
||||
pasted with the page text. If |g:html_no_invalid| is 0, the <input> tags have
|
||||
invalid type; this works in more browsers, but the page will not validate.
|
||||
Note: This method does NOT work in recent versions of Chrome and equivalent
|
||||
browsers; the <input> tags get pasted with the text.
|
||||
|
||||
When "fallback" (default value), the same <input> elements are generated for
|
||||
older browsers, but newer browsers (detected by CSS feature query) hide the
|
||||
<input> elements and instead use generated content in an ::before pseudoelement
|
||||
to display the uncopyable text. This method should work with the largest
|
||||
number of browsers, both old and new.
|
||||
|
||||
When "none", the <input> elements are not generated at all. Only the
|
||||
generated-content method is used. This means that old browsers, notably
|
||||
Internet Explorer, will either copy the text intended not to be copyable, or
|
||||
the non-copyable text may not appear at all. However, this is the most
|
||||
standards-based method, and there will be much less markup.
|
||||
|
||||
*g:html_no_invalid*
|
||||
Default: 0.
|
||||
When 0, if |g:html_prevent_copy| is non-empty and |g:html_use_input_for_pc| is
|
||||
not "none", an invalid attribute is intentionally inserted into the <input>
|
||||
element for the uncopyable areas. This prevents pasting the <input> elements
|
||||
in some applications. Specifically, some versions of Microsoft Word will not
|
||||
paste the <input> elements if they contain this invalid attribute. When 1, no
|
||||
invalid markup is inserted, and the generated page should validate. However,
|
||||
<input> elements may be pasted into some applications and can be difficult to
|
||||
remove afterward.
|
||||
|
||||
*g:html_hover_unfold*
|
||||
Default: 0.
|
||||
When 0, the only way to open a fold generated by 2html.vim with
|
||||
|g:html_dynamic_folds| set, is to click on the generated fold column.
|
||||
When 1, use CSS 2.0 to allow the user to open a fold by moving the mouse
|
||||
cursor over the displayed fold text. This is useful to allow users with
|
||||
disabled javascript to view the folded text.
|
||||
|
||||
Note that old browsers (notably Internet Explorer 6) will not support this
|
||||
feature. Browser-specific markup for IE6 is included to fall back to the
|
||||
normal CSS1 styling so that the folds show up correctly for this browser, but
|
||||
they will not be openable without a foldcolumn.
|
||||
>
|
||||
:let g:html_hover_unfold = 1
|
||||
<
|
||||
*g:html_id_expr*
|
||||
Default: ""
|
||||
Dynamic folding and jumping to line IDs rely on unique IDs within the document
|
||||
to work. If generated HTML is copied into a larger document, these IDs are no
|
||||
longer guaranteed to be unique. Set g:html_id_expr to an expression Vim can
|
||||
evaluate to get a unique string to append to each ID used in a given document,
|
||||
so that the full IDs will be unique even when combined with other content in a
|
||||
larger HTML document. Example, to append _ and the buffer number to each ID: >
|
||||
|
||||
:let g:html_id_expr = '"_" .. bufnr("%")'
|
||||
<
|
||||
To append a string "_mystring" to the end of each ID: >
|
||||
|
||||
:let g:html_id_expr = '"_mystring"'
|
||||
<
|
||||
Note: When converting a diff view to HTML, the expression will only be
|
||||
evaluated for the first window in the diff, and the result used for all the
|
||||
windows.
|
||||
|
||||
*TOhtml-wrap-text* *g:html_pre_wrap*
|
||||
Default: Current 'wrap' setting.
|
||||
When 0, if |g:html_no_pre| is 0 or unset, the text in the generated HTML does
|
||||
not wrap at the edge of the browser window.
|
||||
When 1, if |g:html_use_css| is 1, the CSS 2.0 "white-space:pre-wrap" value is
|
||||
used, causing the text to wrap at whitespace at the edge of the browser
|
||||
window.
|
||||
Explicitly enable text wrapping: >
|
||||
:let g:html_pre_wrap = 1
|
||||
Explicitly disable wrapping: >
|
||||
:let g:html_pre_wrap = 0
|
||||
Go back to default, determine wrapping from 'wrap' setting: >
|
||||
:unlet g:html_pre_wrap
|
||||
<
|
||||
*g:html_no_pre*
|
||||
Default: 0.
|
||||
When 0, buffer text in the generated HTML is surrounded by <pre>...</pre>
|
||||
tags. Series of whitespace is shown as in Vim without special markup, and tab
|
||||
characters can be included literally (see |g:html_expand_tabs|).
|
||||
When 1 (not recommended), the <pre> tags are omitted, and a plain <div> is
|
||||
used instead. Whitespace is replaced by a series of character
|
||||
references, and <br> is used to end each line. This is another way to allow
|
||||
text in the generated HTML is wrap (see |g:html_pre_wrap|) which also works in
|
||||
old browsers, but may cause noticeable differences between Vim's display and
|
||||
the rendered page generated by 2html.vim.
|
||||
>
|
||||
:let g:html_no_pre = 1
|
||||
<
|
||||
*g:html_no_doc*
|
||||
Default: 0.
|
||||
When 1 it doesn't generate a full HTML document with a DOCTYPE, <head>,
|
||||
<body>, etc. If |g:html_use_css| is enabled (the default) you'll have to
|
||||
define the CSS manually. The |g:html_dynamic_folds| and |g:html_line_ids|
|
||||
settings (off by default) also insert some JavaScript.
|
||||
|
||||
|
||||
*g:html_no_links*
|
||||
Default: 0.
|
||||
Don't generate <a> tags for text that looks like an URL.
|
||||
|
||||
*g:html_no_modeline*
|
||||
Default: 0.
|
||||
Don't generate a modeline disabling folding.
|
||||
|
||||
*g:html_expand_tabs*
|
||||
Default: 0 if 'tabstop' is 8, 'expandtab' is 0, 'vartabstop' is not in use,
|
||||
and no fold column or line numbers occur in the generated HTML;
|
||||
1 otherwise.
|
||||
When 1, <Tab> characters in the buffer text are replaced with an appropriate
|
||||
number of space characters, or references if |g:html_no_pre| is 1.
|
||||
When 0, if |g:html_no_pre| is 0 or unset, <Tab> characters in the buffer text
|
||||
are included as-is in the generated HTML. This is useful for when you want to
|
||||
allow copy and paste from a browser without losing the actual whitespace in
|
||||
the source document. Note that this can easily break text alignment and
|
||||
indentation in the HTML, unless set by default.
|
||||
|
||||
Force |2html.vim| to keep <Tab> characters: >
|
||||
:let g:html_expand_tabs = 0
|
||||
<
|
||||
Force tabs to be expanded: >
|
||||
:let g:html_expand_tabs = 1
|
||||
<
|
||||
*TOhtml-encoding-detect* *TOhtml-encoding*
|
||||
It is highly recommended to set your desired encoding with
|
||||
|g:html_use_encoding| for any content which will be placed on a web server.
|
||||
|
||||
If you do not specify an encoding, |2html.vim| uses the preferred IANA name
|
||||
for the current value of 'fileencoding' if set, or 'encoding' if not.
|
||||
'encoding' is always used for certain 'buftype' values. 'fileencoding' will be
|
||||
set to match the chosen document encoding.
|
||||
|
||||
Automatic detection works for the encodings mentioned specifically by name in
|
||||
|encoding-names|, but TOhtml will only automatically use those encodings with
|
||||
wide browser support. However, you can override this to support specific
|
||||
encodings that may not be automatically detected by default (see options
|
||||
below). See https://www.iana.org/assignments/character-sets for the IANA names.
|
||||
|
||||
Note: By default all Unicode encodings are converted to UTF-8 with no BOM in
|
||||
the generated HTML, as recommended by W3C:
|
||||
|
||||
https://www.w3.org/International/questions/qa-choosing-encodings
|
||||
https://www.w3.org/International/questions/qa-byte-order-mark
|
||||
|
||||
*g:html_use_encoding*
|
||||
Default: none, uses IANA name for current 'fileencoding' as above.
|
||||
To overrule all automatic charset detection, set g:html_use_encoding to the
|
||||
name of the charset to be used. It is recommended to set this variable to
|
||||
something widely supported, like UTF-8, for anything you will be hosting on a
|
||||
webserver: >
|
||||
:let g:html_use_encoding = "UTF-8"
|
||||
You can also use this option to omit the line that specifies the charset
|
||||
entirely, by setting g:html_use_encoding to an empty string (NOT recommended): >
|
||||
:let g:html_use_encoding = ""
|
||||
To go back to the automatic mechanism, delete the |g:html_use_encoding|
|
||||
variable: >
|
||||
:unlet g:html_use_encoding
|
||||
<
|
||||
*g:html_encoding_override*
|
||||
Default: none, autoload/tohtml.vim contains default conversions for encodings
|
||||
mentioned by name at |encoding-names|.
|
||||
This option allows |2html.vim| to detect the correct 'fileencoding' when you
|
||||
specify an encoding with |g:html_use_encoding| which is not in the default
|
||||
list of conversions.
|
||||
|
||||
This is a dictionary of charset-encoding pairs that will replace existing
|
||||
pairs automatically detected by TOhtml, or supplement with new pairs.
|
||||
|
||||
Detect the HTML charset "windows-1252" as the encoding "8bit-cp1252": >
|
||||
:let g:html_encoding_override = {'windows-1252': '8bit-cp1252'}
|
||||
<
|
||||
*g:html_charset_override*
|
||||
Default: none, autoload/tohtml.vim contains default conversions for encodings
|
||||
mentioned by name at |encoding-names| and which have wide
|
||||
browser support.
|
||||
This option allows |2html.vim| to detect the HTML charset for any
|
||||
'fileencoding' or 'encoding' which is not detected automatically. You can also
|
||||
use it to override specific existing encoding-charset pairs. For example,
|
||||
TOhtml will by default use UTF-8 for all Unicode/UCS encodings. To use UTF-16
|
||||
and UTF-32 instead, use: >
|
||||
:let g:html_charset_override = {'ucs-4': 'UTF-32', 'utf-16': 'UTF-16'}
|
||||
|
||||
Note that documents encoded in either UTF-32 or UTF-16 have known
|
||||
compatibility problems with some major browsers.
|
||||
|
||||
*g:html_font*
|
||||
Default: "monospace"
|
||||
You can specify the font or fonts used in the converted document using
|
||||
g:html_font. If this option is set to a string, then the value will be
|
||||
surrounded with single quotes. If this option is set to a list then each list
|
||||
item is surrounded by single quotes and the list is joined with commas. Either
|
||||
way, "monospace" is added as the fallback generic family name and the entire
|
||||
result used as the font family (using CSS) or font face (if not using CSS).
|
||||
Examples: >
|
||||
|
||||
" font-family: 'Consolas', monospace;
|
||||
:let g:html_font = "Consolas"
|
||||
|
||||
" font-family: 'DejaVu Sans Mono', 'Consolas', monospace;
|
||||
:let g:html_font = ["DejaVu Sans Mono", "Consolas"]
|
||||
<
|
||||
*convert-to-XML* *convert-to-XHTML* *g:html_use_xhtml*
|
||||
Default: 0.
|
||||
When 0, generate standard HTML 4.01 (strict when possible).
|
||||
When 1, generate XHTML 1.0 instead (XML compliant HTML).
|
||||
>
|
||||
:let g:html_use_xhtml = 1
|
||||
<
|
||||
==============================================================================
|
||||
5. Syntax file remarks *:syn-file-remarks*
|
||||
|
||||
|
||||
@ -635,6 +635,7 @@ Commands:
|
||||
:lcscope
|
||||
:scscope
|
||||
:Vimuntar
|
||||
The old `:TOhtml`, replaced by a Lua version (contains many differences)
|
||||
|
||||
Compile-time features:
|
||||
Emacs tags support
|
||||
|
||||
1335
runtime/lua/tohtml.lua
Normal file
1335
runtime/lua/tohtml.lua
Normal file
File diff suppressed because it is too large
Load Diff
11
runtime/plugin/tohtml.lua
Normal file
11
runtime/plugin/tohtml.lua
Normal file
@ -0,0 +1,11 @@
|
||||
if vim.g.loaded_2html_plugin ~= nil then
|
||||
return
|
||||
end
|
||||
vim.g.loaded_2html_plugin = true
|
||||
|
||||
vim.api.nvim_create_user_command('TOhtml', function(args)
|
||||
local outfile = args.args ~= '' and args.args or vim.fn.tempname() .. '.html'
|
||||
local html = require('tohtml').tohtml()
|
||||
vim.fn.writefile(html, outfile)
|
||||
vim.cmd.split(outfile)
|
||||
end, { bar = true, nargs = '?' })
|
||||
@ -1,254 +0,0 @@
|
||||
" Vim plugin for converting a syntax highlighted file to HTML.
|
||||
" Maintainer: Ben Fritz <fritzophrenic@gmail.com>
|
||||
" Last Change: 2023 Sep 07
|
||||
"
|
||||
" The core of the code is in $VIMRUNTIME/autoload/tohtml.vim and
|
||||
" $VIMRUNTIME/syntax/2html.vim
|
||||
"
|
||||
if exists('g:loaded_2html_plugin')
|
||||
finish
|
||||
endif
|
||||
let g:loaded_2html_plugin = 'vim9.0_v2'
|
||||
|
||||
"
|
||||
" Changelog: {{{
|
||||
" 9.0_v2 (this version): - Warn if using deprecated g:use_xhtml option
|
||||
" - Change default g:html_use_input_for_pc to "none"
|
||||
" instead of "fallback". All modern browsers support
|
||||
" the "user-select: none" and "content:" CSS
|
||||
" properties so the older method relying on extra
|
||||
" markup and unspecified browser/app clipboard
|
||||
" handling is only needed in rare special cases.
|
||||
" - Fix SourceForge issue #33: generate diff filler
|
||||
" correctly when new lines have been added to or
|
||||
" removed from end of buffer.
|
||||
" - Fix SourceForge issue #32/Vim Github issue #8547:
|
||||
" use translated highlight ID for styling the
|
||||
" special-use group names (e.g. LineNr) used
|
||||
" directly by name in the 2html processing.
|
||||
" - Fix SourceForge issue #26, refactoring to use
|
||||
" :let-heredoc style string assignment and
|
||||
" additional fixes for ".." vs. "." style string
|
||||
" concatenation. Requires Vim v8.1.1354 or higher.
|
||||
" 9.0_v1 (Vim 9.0.1275): - Implement g:html_no_doc and g:html_no_modeline
|
||||
" for diff mode. Add tests.
|
||||
" (Vim 9.0.1122): NOTE: no version string update for this version!
|
||||
" - Bugfix for variable name in g:html_no_doc
|
||||
" (Vim 9.0.0819): NOTE: no version string update for this version!
|
||||
" - Add options g:html_no_doc, g:html_no_lines,
|
||||
" and g:html_no_modeline (partially included in Vim
|
||||
" runtime prior to version string update).
|
||||
" - Updates for new Vim9 string append style (i.e. use
|
||||
" ".." instead of "."). Requires Vim version
|
||||
" 8.1.1114 or higher.
|
||||
"
|
||||
" 8.1 updates: {{{
|
||||
" 8.1_v2 (Vim 8.1.2312): - Fix SourceForge issue #19: fix calculation of tab
|
||||
" stop position to use in expanding a tab, when that
|
||||
" tab occurs after a syntax match which in turn
|
||||
" comes after previously expanded tabs.
|
||||
" - Set eventignore while splitting a window for the
|
||||
" destination file to ignore FileType events;
|
||||
" speeds up processing when the destination file
|
||||
" already exists and HTML highlight takes too long.
|
||||
" - Fix SourceForge issue #20: progress bar could not be
|
||||
" seen when DiffDelete background color matched
|
||||
" StatusLine background color. Added TOhtmlProgress
|
||||
" highlight group for manual user override, but
|
||||
" calculate it to be visible compared to StatusLine
|
||||
" by default.
|
||||
" - Fix SourceForge issue #1: Remove workaround for old
|
||||
" browsers which don't support 'ch' CSS unit, since
|
||||
" all modern browsers, including IE>=9, support it.
|
||||
" - Fix SourceForge issue #10: support termguicolors
|
||||
" - Fix SourceForge issue #21: default to using
|
||||
" generated content instead of <input> tags for
|
||||
" uncopyable text, so that text is correctly
|
||||
" prevented from being copied in chrome. Use
|
||||
" g:html_use_input_for_pc option to control the
|
||||
" method used.
|
||||
" - Switch to HTML5 to allow using vnu as a validator
|
||||
" in unit test.
|
||||
" - Fix fallback sizing of <input> tags for browsers
|
||||
" without "ch" support.
|
||||
" - Fix cursor on unselectable diff filler text.
|
||||
" 8.1_v1 (Vim 8.1.0528): - Fix SourceForge issue #6: Don't generate empty
|
||||
" script tag.
|
||||
" - Fix SourceForge issue #5: javascript should
|
||||
" declare variables with "var".
|
||||
" - Fix SourceForge issue #13: errors thrown sourcing
|
||||
" 2html.vim directly when plugins not loaded.
|
||||
" - Fix SourceForge issue #16: support 'vartabstop'.
|
||||
"}}}
|
||||
"
|
||||
" 7.4 updates: {{{
|
||||
" 7.4_v2 (Vim 7.4.0899): Fix error raised when converting a diff containing
|
||||
" an empty buffer. Jan Stocker: allow g:html_font to
|
||||
" take a list so it is easier to specfiy fallback
|
||||
" fonts in the generated CSS.
|
||||
" 7.4_v1 (Vim 7.4.0000): Fix modeline mangling for new "Vim:" format, and
|
||||
" also for version-specific modelines like "vim>703:".
|
||||
"}}}
|
||||
"
|
||||
" 7.3 updates: {{{
|
||||
" 7.3_v14 (Vim 7.3.1246): Allow suppressing line number anchors using
|
||||
" g:html_line_ids=0. Allow customizing
|
||||
" important IDs (like line IDs and fold IDs) using
|
||||
" g:html_id_expr evaluated when the buffer conversion
|
||||
" is started.
|
||||
" 7.3_v13 (Vim 7.3.1088): Keep foldmethod at manual in the generated file and
|
||||
" insert modeline to set it to manual.
|
||||
" Fix bug: diff mode with 2 unsaved buffers creates a
|
||||
" duplicate of one buffer instead of including both.
|
||||
" Add anchors to each line so you can put '#L123'
|
||||
" or '#123' at the end of the URL to jump to line 123
|
||||
" (idea by Andy Spencer). Add javascript to open folds
|
||||
" to show the anchor being jumped to if it is hidden.
|
||||
" Fix XML validation error: &nsbp; not part of XML.
|
||||
" Allow TOhtml to chain together with other commands
|
||||
" using |.
|
||||
" 7.3_v12 (Vim 7.3.0616): Fix modeline mangling to also work for when multiple
|
||||
" highlight groups make up the start-of-modeline text.
|
||||
" Improve render time of page with uncopyable regions
|
||||
" by not using one-input-per-char. Change name of
|
||||
" uncopyable option from html_unselectable to
|
||||
" html_prevent_copy. Added html_no_invalid option and
|
||||
" default to inserting invalid markup for uncopyable
|
||||
" regions to prevent MS Word from pasting undeletable
|
||||
" <input> elements. Fix 'cpo' handling (Thilo Six).
|
||||
" 7.3_v12b1: Add html_unselectable option. Rework logic to
|
||||
" eliminate post-processing substitute commands in
|
||||
" favor of doing the work up front. Remove unnecessary
|
||||
" special treatment of 'LineNr' highlight group. Minor
|
||||
" speed improvements. Fix modeline mangling in
|
||||
" generated output so it works for text in the first
|
||||
" column. Fix missing line number and fold column in
|
||||
" diff filler lines. Fix that some fonts have a 1px
|
||||
" gap (using a dirty hack, improvements welcome). Add
|
||||
" "colorscheme" meta tag. Does NOT include support for
|
||||
" the new default foldtext added in v11, as the patch
|
||||
" adding it has not yet been included in Vim.
|
||||
" 7.3_v11 ( unreleased ): Support new default foldtext from patch by Christian
|
||||
" Brabandt in
|
||||
" http://groups.google.com/d/topic/vim_dev/B6FSGfq9VoI/discussion.
|
||||
" This patch has not yet been included in Vim, thus
|
||||
" these changes are removed in the next version.
|
||||
" 7.3_v10 (Vim 7.3.0227): Fix error E684 when converting a range wholly inside
|
||||
" multiple nested folds with dynamic folding on.
|
||||
" Also fix problem with foldtext in this situation.
|
||||
" 7.3_v9 (Vim 7.3.0170): Add html_pre_wrap option active with html_use_css
|
||||
" and without html_no_pre, default value same as
|
||||
" 'wrap' option, (Andy Spencer). Don't use
|
||||
" 'fileencoding' for converted document encoding if
|
||||
" 'buftype' indicates a special buffer which isn't
|
||||
" written.
|
||||
" 7.3_v8 (Vim 7.3.0100): Add html_expand_tabs option to allow leaving tab
|
||||
" characters in generated output (Andy Spencer).
|
||||
" Escape text that looks like a modeline so Vim
|
||||
" doesn't use anything in the converted HTML as a
|
||||
" modeline. Bugfixes: Fix folding when a fold starts
|
||||
" before the conversion range. Remove fold column when
|
||||
" there are no folds.
|
||||
" 7.3_v7 (Vim 7-3-0063): see betas released on vim_dev below:
|
||||
" 7.3_v7b3: Fixed bug, convert Unicode to UTF-8 all the way.
|
||||
" 7.3_v7b2: Remove automatic detection of encodings that are not
|
||||
" supported by all major browsers according to
|
||||
" http://wiki.whatwg.org/wiki/Web_Encodings and
|
||||
" convert to UTF-8 for all Unicode encodings. Make
|
||||
" HTML encoding to Vim encoding detection be
|
||||
" case-insensitive for built-in pairs.
|
||||
" 7.3_v7b1: Remove use of setwinvar() function which cannot be
|
||||
" called in restricted mode (Andy Spencer). Use
|
||||
" 'fencoding' instead of 'encoding' to determine by
|
||||
" charset, and make sure the 'fenc' of the generated
|
||||
" file matches its indicated charset. Add charsets for
|
||||
" all of Vim's natively supported encodings.
|
||||
" 7.3_v6 (Vim 7.3.0000): Really fix bug with 'nowrapscan', 'magic' and other
|
||||
" user settings interfering with diff mode generation,
|
||||
" trailing whitespace (e.g. line number column) when
|
||||
" using html_no_pre, and bugs when using
|
||||
" html_hover_unfold.
|
||||
" 7.3_v5 ( unreleased ): Fix bug with 'nowrapscan' and also with out-of-sync
|
||||
" folds in diff mode when first line was folded.
|
||||
" 7.3_v4 (Vim 7.3.0000): Bugfixes, especially for xhtml markup, and diff mode
|
||||
" 7.3_v3 (Vim 7.3.0000): Refactor option handling and make html_use_css
|
||||
" default to true when not set to anything. Use strict
|
||||
" doctypes where possible. Rename use_xhtml option to
|
||||
" html_use_xhtml for consistency. Use .xhtml extension
|
||||
" when using this option. Add meta tag for settings.
|
||||
" 7.3_v2 (Vim 7.3.0000): Fix syntax highlighting in diff mode to use both the
|
||||
" diff colors and the normal syntax colors
|
||||
" 7.3_v1 (Vim 7.3.0000): Add conceal support and meta tags in output
|
||||
"}}}
|
||||
"}}}
|
||||
|
||||
" TODO: {{{
|
||||
" * Check the issue tracker:
|
||||
" https://sourceforge.net/p/vim-tohtml/issues/search/?q=%21status%3Aclosed
|
||||
" * Options for generating the CSS in external style sheets. New :TOcss
|
||||
" command to convert the current color scheme into a (mostly) generic CSS
|
||||
" stylesheet which can be re-used. Alternate stylesheet support? Good start
|
||||
" by Erik Falor
|
||||
" ( https://groups.google.com/d/topic/vim_use/7XTmC4D22dU/discussion ).
|
||||
" * Add optional argument to :TOhtml command to specify mode (gui, cterm,
|
||||
" term) to use for the styling. Suggestion by "nacitar".
|
||||
" * Add way to override or specify which RGB colors map to the color numbers
|
||||
" in cterm. Get better defaults than just guessing? Suggestion by "nacitar".
|
||||
" * Disable filetype detection until after all processing is done.
|
||||
" * Add option for not generating the hyperlink on stuff that looks like a
|
||||
" URL? Or just color the link to fit with the colorscheme (and only special
|
||||
" when hovering)?
|
||||
" * Bug: Opera does not allow printing more than one page if uncopyable
|
||||
" regions is turned on. Possible solution: Add normal text line numbers with
|
||||
" display:none, set to display:inline for print style sheets, and hide
|
||||
" <input> elements for print, to allow Opera printing multiple pages (and
|
||||
" other uncopyable areas?). May need to make the new text invisible to IE
|
||||
" with conditional comments to prevent copying it, IE for some reason likes
|
||||
" to copy hidden text. Other browsers too?
|
||||
" * Bug: still a 1px gap throughout the fold column when html_prevent_copy is
|
||||
" "fn" in some browsers. Specifically, in Chromium on Ubuntu (but not Chrome
|
||||
" on Windows). Perhaps it is font related?
|
||||
" * Bug: still some gaps in the fold column when html_prevent_copy contains
|
||||
" 'd' and showing the whole diff (observed in multiple browsers). Only gaps
|
||||
" on diff lines though.
|
||||
" * Undercurl support via CSS3, with fallback to dotted or something:
|
||||
" https://groups.google.com/d/topic/vim_use/BzXA6He1pHg/discussion
|
||||
" * Redo updates for modified default foldtext (v11) when/if the patch is
|
||||
" accepted to modify it.
|
||||
" * Test case +diff_one_file-dynamic_folds+expand_tabs-hover_unfold
|
||||
" +ignore_conceal-ignore_folding+no_foldcolumn+no_pre+no_progress
|
||||
" +number_lines-pre_wrap-use_css+use_xhtml+whole_filler.xhtml
|
||||
" does not show the whole diff filler as it is supposed to?
|
||||
" * Bug: when 'isprint' is wrong for the current encoding, will generate
|
||||
" invalid content. Can/should anything be done about this? Maybe a separate
|
||||
" plugin to correct 'isprint' based on encoding?
|
||||
" * Check to see if the windows-125\d encodings actually work in Unix without
|
||||
" the 8bit- prefix. Add prefix to autoload dictionaries for Unix if not.
|
||||
" * Font auto-detection similar to
|
||||
" http://www.vim.org/scripts/script.php?script_id=2384 but for a variety of
|
||||
" platforms.
|
||||
" * Pull in code from http://www.vim.org/scripts/script.php?script_id=3113 :
|
||||
" - listchars support
|
||||
" - full-line background highlight
|
||||
" - other?
|
||||
" * Make it so deleted lines in a diff don't create side-scrolling (get it
|
||||
" free with full-line background highlight above).
|
||||
" * Restore open/closed folds and cursor position after processing each file
|
||||
" with option not to restore for speed increase.
|
||||
" * Add extra meta info (generation time, etc.)?
|
||||
" * Tidy up so we can use strict doctype in even more situations
|
||||
" * Implementation detail: add threshold for writing the lines to the html
|
||||
" buffer before we're done (5000 or so lines should do it)
|
||||
" * TODO comments for code cleanup scattered throughout
|
||||
"}}}
|
||||
|
||||
" Define the :TOhtml command when:
|
||||
" - 'compatible' is not set
|
||||
" - this plugin or user override was not already loaded
|
||||
" - user commands are available. {{{
|
||||
if !&cp && !exists(":TOhtml") && has("user_commands")
|
||||
command -range=% -bar TOhtml :call tohtml#Convert2HTML(<line1>, <line2>)
|
||||
endif "}}}
|
||||
|
||||
" Make sure any patches will probably use consistent indent
|
||||
" vim: ts=8 sw=2 sts=2 noet fdm=marker
|
||||
File diff suppressed because it is too large
Load Diff
@ -161,6 +161,7 @@ local config = {
|
||||
'iter.lua',
|
||||
'snippet.lua',
|
||||
'text.lua',
|
||||
'tohtml.lua',
|
||||
},
|
||||
files = {
|
||||
'runtime/lua/vim/iter.lua',
|
||||
@ -189,6 +190,7 @@ local config = {
|
||||
'runtime/lua/vim/_meta/lpeg.lua',
|
||||
'runtime/lua/vim/_meta/re.lua',
|
||||
'runtime/lua/vim/_meta/spell.lua',
|
||||
'runtime/lua/tohtml.lua',
|
||||
},
|
||||
fn_xform = function(fun)
|
||||
if contains(fun.module, { 'vim.uri', 'vim.shared', 'vim._editor' }) then
|
||||
@ -232,6 +234,9 @@ local config = {
|
||||
then
|
||||
return 'VIM.' .. name:upper()
|
||||
end
|
||||
if name == 'tohtml' then
|
||||
return 'Lua module: tohtml'
|
||||
end
|
||||
return 'Lua module: vim.' .. name
|
||||
end,
|
||||
helptag_fmt = function(name)
|
||||
@ -239,6 +244,8 @@ local config = {
|
||||
return '*lua-vim*'
|
||||
elseif name == '_options' then
|
||||
return '*lua-vimscript*'
|
||||
elseif name == 'tohtml' then
|
||||
return '*tohtml*'
|
||||
end
|
||||
return '*vim.' .. name:lower() .. '*'
|
||||
end,
|
||||
|
||||
370
test/functional/plugin/tohtml_spec.lua
Normal file
370
test/functional/plugin/tohtml_spec.lua
Normal file
@ -0,0 +1,370 @@
|
||||
local Screen = require('test.functional.ui.screen')
|
||||
local helpers = require('test.functional.helpers')(after_each)
|
||||
|
||||
local clear = helpers.clear
|
||||
local exec = helpers.exec
|
||||
local exec_lua = helpers.exec_lua
|
||||
local eq = helpers.eq
|
||||
local fn = helpers.fn
|
||||
local api = helpers.api
|
||||
local insert = helpers.insert
|
||||
|
||||
local function html_syntax_match()
|
||||
local styles =
|
||||
vim.split(api.nvim_exec2([[/<style>/+,/<\/style>/-p]], { output = true }).output, '\n')
|
||||
local attrnames = {
|
||||
['font%-weight: bold'] = 'bold',
|
||||
['text%-decoration%-line: [^;]*underline'] = 'underline',
|
||||
['font%-style: italic'] = 'italic',
|
||||
['text%-decoration%-line: [^;]*line%-through'] = 'strikethrough',
|
||||
}
|
||||
local hls = {}
|
||||
for _, style in ipairs(styles) do
|
||||
local attr = {}
|
||||
for match, attrname in pairs(attrnames) do
|
||||
if style:find(match) then
|
||||
---@type boolean
|
||||
attr[attrname] = true
|
||||
end
|
||||
end
|
||||
if style:find('text%-decoration%-style: wavy') and attr.underline then
|
||||
---@type boolean
|
||||
attr.underline = nil
|
||||
attr.undercurl = true
|
||||
end
|
||||
attr.bg = style:match('background%-color: #(%x+)')
|
||||
if attr.bg then
|
||||
attr.bg = tonumber(attr.bg, 16)
|
||||
end
|
||||
attr.fg = style:match('[^%-]color: #(%x+)')
|
||||
if attr.fg then
|
||||
attr.fg = tonumber(attr.fg, 16)
|
||||
end
|
||||
if style:match('^%.(%w+)') then
|
||||
---@type table
|
||||
hls[style:match('^%.(%w+)')] = attr
|
||||
end
|
||||
end
|
||||
local whitelist = {
|
||||
'fg',
|
||||
'bg',
|
||||
--'sp',
|
||||
--'blend',
|
||||
'bold',
|
||||
--'standout',
|
||||
'underline',
|
||||
'undercurl',
|
||||
--'underdouble',
|
||||
--'underdotted',
|
||||
--'underdashed',
|
||||
'strikethrough',
|
||||
'italic',
|
||||
--'reverse',
|
||||
--'nocombine',
|
||||
}
|
||||
for name, attrs_old in
|
||||
pairs(api.nvim_get_hl(0, { link = true }) --[[@as table<string,table>]])
|
||||
do
|
||||
---@type table
|
||||
local other = hls[name:gsub('%.', '-'):gsub('@', '-')]
|
||||
if other then
|
||||
local attrs = {}
|
||||
for _, attrname in ipairs(whitelist) do
|
||||
---@type table
|
||||
attrs[attrname] = attrs_old[attrname]
|
||||
end
|
||||
eq(attrs, other)
|
||||
end
|
||||
end
|
||||
return hls
|
||||
end
|
||||
|
||||
local function html_to_extmarks()
|
||||
local buf = api.nvim_get_current_buf()
|
||||
local ns = api.nvim_create_namespace 'test-namespace'
|
||||
api.nvim_buf_clear_namespace(buf, ns, 0, -1)
|
||||
exec 'silent! norm! ggd/^<pre>$\rddG3dk'
|
||||
local stack = {}
|
||||
exec [[set filetype=]]
|
||||
exec [[silent! %s/</¤/g]]
|
||||
exec [[silent! %s/"/"/g]]
|
||||
exec [[silent! %s/&/\&/g]]
|
||||
exec [[silent! %s/>/>/g]]
|
||||
exec [[silent! %s/</</g]]
|
||||
for _, match in
|
||||
ipairs(
|
||||
fn.matchbufline(buf, [[¤span class="\([^"]\+\)">\|¤/span>]], 1, '$', { submatches = true }) --[[@as (table[])]]
|
||||
)
|
||||
do
|
||||
if match.text == '¤/span>' then
|
||||
local val = table.remove(stack)
|
||||
api.nvim_buf_set_extmark(buf, ns, val.lnum - 1, val.byteidx, {
|
||||
hl_group = val.submatches[1],
|
||||
end_row = match.lnum - 1,
|
||||
end_col = match.byteidx,
|
||||
})
|
||||
else
|
||||
table.insert(stack, match)
|
||||
end
|
||||
end
|
||||
exec [[silent! %s/¤\/span>//g]]
|
||||
exec [[silent! %s/¤span[^>]*>//g]]
|
||||
end
|
||||
|
||||
---@param screen test.functional.ui.screen
|
||||
---@param func function?
|
||||
local function run_tohtml_and_assert(screen, func)
|
||||
exec('norm! ggO-;')
|
||||
exec('norm! gg0f;:\r')
|
||||
screen:sleep(10)
|
||||
local snapshot = { grid = screen:get_snapshot().grid, attr_ids = screen:get_snapshot().attr_ids }
|
||||
do
|
||||
(func or exec)('TOhtml')
|
||||
end
|
||||
exec('only')
|
||||
html_syntax_match()
|
||||
html_to_extmarks()
|
||||
exec('norm! gg0f;:\r')
|
||||
screen:sleep(10)
|
||||
eq(snapshot, { grid = screen:get_snapshot().grid, attr_ids = screen:get_snapshot().attr_ids })
|
||||
end
|
||||
|
||||
describe(':TOhtml', function()
|
||||
--- @type test.functional.ui.screen
|
||||
local screen
|
||||
before_each(function()
|
||||
clear({ args = { '--clean' } })
|
||||
screen = Screen.new(80, 80)
|
||||
screen:attach({ term_name = 'xterm' })
|
||||
exec('colorscheme default')
|
||||
end)
|
||||
|
||||
it('expected internal html generated', function()
|
||||
insert([[line]])
|
||||
exec('set termguicolors')
|
||||
local bg = fn.synIDattr(fn.hlID('Normal'), 'bg#', 'gui')
|
||||
local fg = fn.synIDattr(fn.hlID('Normal'), 'fg#', 'gui')
|
||||
exec_lua [[
|
||||
local outfile = vim.fn.tempname() .. '.html'
|
||||
local html = require('tohtml').tohtml(0,{title="title",font="dumyfont"})
|
||||
vim.fn.writefile(html, outfile)
|
||||
vim.cmd.split(outfile)
|
||||
]]
|
||||
local out_file = api.nvim_buf_get_name(api.nvim_get_current_buf())
|
||||
eq({
|
||||
'<!DOCTYPE html>',
|
||||
'<html>',
|
||||
'<head>',
|
||||
'<meta charset="UTF-8">',
|
||||
'<title>title</title>',
|
||||
('<meta name="colorscheme" content="%s"></meta>'):format(api.nvim_get_var('colors_name')),
|
||||
'<style>',
|
||||
'* {font-family: dumyfont,monospace}',
|
||||
('body {background-color: %s; color: %s}'):format(bg, fg),
|
||||
'</style>',
|
||||
'</head>',
|
||||
'<body style="display: flex">',
|
||||
'<pre>',
|
||||
'line',
|
||||
'',
|
||||
'</pre>',
|
||||
'</body>',
|
||||
'</html>',
|
||||
}, fn.readfile(out_file))
|
||||
end)
|
||||
|
||||
it('highlight attributes generated', function()
|
||||
--Make sure to uncomment the attribute in `html_syntax_match()`
|
||||
exec('hi LINE gui=' .. table.concat({
|
||||
'bold',
|
||||
'underline',
|
||||
'italic',
|
||||
'strikethrough',
|
||||
}, ','))
|
||||
exec('hi UNDERCURL gui=undercurl')
|
||||
exec('syn keyword LINE line')
|
||||
exec('syn keyword UNDERCURL undercurl')
|
||||
insert('line\nundercurl')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
it('syntax', function()
|
||||
insert [[
|
||||
function main()
|
||||
print("hello world")
|
||||
end
|
||||
]]
|
||||
exec('set termguicolors')
|
||||
exec('syntax enable')
|
||||
exec('setf lua')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
it('diff', function()
|
||||
exec('set diffopt=')
|
||||
insert [[
|
||||
diffadd
|
||||
nochage
|
||||
diffchange1
|
||||
]]
|
||||
exec('new')
|
||||
insert [[
|
||||
nochage
|
||||
diffchange2
|
||||
diffremove
|
||||
]]
|
||||
exec('set diff')
|
||||
exec('close')
|
||||
exec('set diff')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
it('treesitter', function()
|
||||
insert [[
|
||||
function main()
|
||||
print("hello world")
|
||||
end
|
||||
]]
|
||||
exec('setf lua')
|
||||
exec_lua('vim.treesitter.start()')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
it('matchadd', function()
|
||||
insert [[
|
||||
line
|
||||
]]
|
||||
fn.matchadd('Visual', 'line')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
describe('conceallevel', function()
|
||||
local function run(level)
|
||||
insert([[
|
||||
line0
|
||||
line1
|
||||
line2
|
||||
line3
|
||||
]])
|
||||
local ns = api.nvim_create_namespace ''
|
||||
fn.matchadd('Conceal', 'line1', 3, 5, { conceal = 'a' })
|
||||
api.nvim_buf_set_extmark(0, ns, 2, 0, { conceal = 'a', end_col = 5 })
|
||||
exec(':syntax match Conceal "line3" conceal cchar=a')
|
||||
exec('set conceallevel=' .. level)
|
||||
run_tohtml_and_assert(screen)
|
||||
end
|
||||
it('conceallevel=0', function()
|
||||
run(0)
|
||||
end)
|
||||
it('conceallevel=1', function()
|
||||
run(1)
|
||||
end)
|
||||
it('conceallevel=2', function()
|
||||
run(2)
|
||||
end)
|
||||
it('conceallevel=3', function()
|
||||
run(3)
|
||||
end)
|
||||
end)
|
||||
|
||||
describe('extmarks', function()
|
||||
it('virt_text', function()
|
||||
insert [[
|
||||
line1
|
||||
line2
|
||||
line3
|
||||
line4
|
||||
]]
|
||||
local ns = api.nvim_create_namespace ''
|
||||
api.nvim_buf_set_extmark(0, ns, 0, 0, { virt_text = { { 'foo' } } })
|
||||
api.nvim_buf_set_extmark(
|
||||
0,
|
||||
ns,
|
||||
1,
|
||||
0,
|
||||
{ virt_text = { { 'foo' } }, virt_text_pos = 'overlay' }
|
||||
)
|
||||
api.nvim_buf_set_extmark(0, ns, 2, 0, { virt_text = { { 'foo' } }, virt_text_pos = 'inline' })
|
||||
--api.nvim_buf_set_extmark(0,ns,3,0,{virt_text={{'foo'}},virt_text_pos='right_align'})
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
it('highlgith', function()
|
||||
insert [[
|
||||
line1
|
||||
]]
|
||||
local ns = api.nvim_create_namespace ''
|
||||
api.nvim_buf_set_extmark(0, ns, 0, 0, { end_col = 2, hl_group = 'Visual' })
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
it('virt_line', function()
|
||||
insert [[
|
||||
line1
|
||||
line2
|
||||
]]
|
||||
local ns = api.nvim_create_namespace ''
|
||||
api.nvim_buf_set_extmark(0, ns, 1, 0, { end_col = 2, virt_lines = { { { 'foo' } } } })
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
end)
|
||||
|
||||
it('listchars', function()
|
||||
exec('setlocal list')
|
||||
exec(
|
||||
'setlocal listchars=eol:$,tab:<->,space:-,multispace:++,lead:_,leadmultispace:##,trail:&,nbsp:%'
|
||||
)
|
||||
fn.setline(1, '\tfoo\t')
|
||||
fn.setline(2, ' foo foo ')
|
||||
fn.setline(3, ' foo foo ')
|
||||
fn.setline(4, 'foo\x2cfoo')
|
||||
run_tohtml_and_assert(screen)
|
||||
exec('new|only')
|
||||
fn.setline(1, '\tfoo\t')
|
||||
exec('setlocal list')
|
||||
exec('setlocal listchars=tab:a-')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
it('folds', function()
|
||||
insert([[
|
||||
line1
|
||||
line2
|
||||
]])
|
||||
exec('set foldtext=foldtext()')
|
||||
exec('%fo')
|
||||
run_tohtml_and_assert(screen)
|
||||
end)
|
||||
|
||||
it('statuscol', function()
|
||||
local function run()
|
||||
local buf = api.nvim_get_current_buf()
|
||||
run_tohtml_and_assert(screen, function()
|
||||
exec_lua [[
|
||||
local outfile = vim.fn.tempname() .. '.html'
|
||||
local html = require('tohtml').tohtml(0,{number_lines=true})
|
||||
vim.fn.writefile(html, outfile)
|
||||
vim.cmd.split(outfile)
|
||||
]]
|
||||
end)
|
||||
api.nvim_set_current_buf(buf)
|
||||
end
|
||||
insert([[
|
||||
line1
|
||||
line2
|
||||
]])
|
||||
exec('setlocal relativenumber')
|
||||
run()
|
||||
exec('setlocal norelativenumber')
|
||||
exec('setlocal number')
|
||||
run()
|
||||
exec('setlocal relativenumber')
|
||||
run()
|
||||
exec('setlocal signcolumn=yes:2')
|
||||
run()
|
||||
exec('setlocal foldcolumn=2')
|
||||
run()
|
||||
exec('setlocal norelativenumber')
|
||||
run()
|
||||
exec('setlocal signcolumn=no')
|
||||
run()
|
||||
end)
|
||||
end)
|
||||
Loading…
Reference in New Issue
Block a user