Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

adding Rename and tComment to Vim along with several vimrc changes

  • Loading branch information...
commit 08fcef0aeb5733efe3a4795199febc9ef01947e2 1 parent 78ced39
@ryanb authored
View
0  gitignore 100644 → 100755
File mode changed
View
1  vim/.VimballRecord
@@ -0,0 +1 @@
+tComment.vba: call delete('/Users/rbates/.vim/doc/tComment.txt')|call delete('/Users/rbates/.vim/plugin/tComment.vim')|call delete('/Users/rbates/.vim/autoload/tcomment.vim')
@blueyed
blueyed added a note

Can this refer to "~" (or something similar dynamic), instead of your own / hardwired directory?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
View
576 vim/autoload/tcomment.vim
@@ -0,0 +1,576 @@
+" tcomment.vim
+" @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim])
+" @Website: http://www.vim.org/account/profile.php?user_id=4037
+" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created: 2007-09-17.
+" @Last Change: 2009-02-15.
+" @Revision: 0.0.66
+
+if &cp || exists("loaded_tcomment_autoload")
+ finish
+endif
+let loaded_tcomment_autoload = 1
+
+
+function! s:DefaultValue(option)
+ exec 'let '. a:option .' = &'. a:option
+ exec 'set '. a:option .'&'
+ exec 'let default = &'. a:option
+ exec 'let &'. a:option .' = '. a:option
+ return default
+endf
+
+let s:defaultComments = s:DefaultValue('comments')
+let s:defaultCommentString = s:DefaultValue('commentstring')
+let s:nullCommentString = '%s'
+
+" tcomment#Comment(line1, line2, ?commentMode, ?commentAnyway, ?commentBegin, ?commentEnd)
+" commentMode:
+" G ... guess
+" B ... block
+" i ... maybe inline, guess
+" I ... inline
+" R ... right
+" v ... visual
+" o ... operator
+function! tcomment#Comment(beg, end, ...)
+ " save the cursor position
+ let co = col('.')
+ let li = line('.')
+ let s:pos_end = getpos("'>")
+ let commentMode = a:0 >= 1 ? a:1 : 'G'
+ let commentAnyway = a:0 >= 2 ? (a:2 == '!') : 0
+ " TLogVAR a:beg, a:end, a:1, commentMode, commentAnyway
+ if commentMode =~# 'i'
+ let commentMode = substitute(commentMode, '\Ci', line("'<") == line("'>") ? 'I' : 'G', 'g')
+ endif
+ if commentMode =~# 'R' || commentMode =~# 'I'
+ let cstart = col("'<")
+ if cstart == 0
+ let cstart = col('.')
+ endif
+ if commentMode =~# 'R'
+ let commentMode = substitute(commentMode, '\CR', 'G', 'g')
+ let cend = 0
+ else
+ let cend = col("'>")
+ if commentMode =~# 'o'
+ let cend += 1
+ endif
+ endif
+ else
+ let cstart = 0
+ let cend = 0
+ endif
+ " TLogVAR commentMode, cstart, cend
+ " get the correct commentstring
+ if a:0 >= 3 && a:3 != ''
+ let cms = s:EncodeCommentPart(a:3) .'%s'
+ if a:0 >= 4 && a:4 != ''
+ let cms = cms . s:EncodeCommentPart(a:4)
+ endif
+ else
+ let [cms, commentMode] = s:GetCommentString(a:beg, a:end, commentMode)
+ endif
+ let cms0 = s:BlockGetCommentString(cms)
+ let cms0 = escape(cms0, '\')
+ " make whitespace optional; this conflicts with comments that require some
+ " whitespace
+ let cmtCheck = substitute(cms0, '\([ ]\)', '\1\\?', 'g')
+ " turn commentstring into a search pattern
+ let cmtCheck = s:SPrintF(cmtCheck, '\(\_.\{-}\)')
+ " set commentMode and indentStr
+ let [indentStr, uncomment] = s:CommentDef(a:beg, a:end, cmtCheck, commentMode, cstart, cend)
+ " TLogVAR indentStr, uncomment
+ if commentAnyway
+ let uncomment = 0
+ endif
+ " go
+ if commentMode =~# 'B'
+ " We want a comment block
+ call s:CommentBlock(a:beg, a:end, uncomment, cmtCheck, cms, indentStr)
+ else
+ " call s:CommentLines(a:beg, a:end, cstart, cend, uncomment, cmtCheck, cms0, indentStr)
+ " We want commented lines
+ " final search pattern for uncommenting
+ let cmtCheck = escape('\V\^\(\s\{-}\)'. cmtCheck .'\$', '"/\')
+ " final pattern for commenting
+ let cmtReplace = escape(cms0, '"/')
+ silent exec a:beg .','. a:end .'s/\V'.
+ \ s:StartRx(cstart) . indentStr .'\zs\(\.\{-}\)'. s:EndRx(cend) .'/'.
+ \ '\=s:ProcessedLine('. uncomment .', submatch(0), "'. cmtCheck .'", "'. cmtReplace .'")/ge'
+ endif
+ " reposition cursor
+ " TLogVAR commentMode
+ if commentMode =~ '>'
+ call setpos('.', s:pos_end)
+ else
+ " TLogVAR li, co
+ call cursor(li, co)
+ endif
+endf
+
+function! tcomment#Operator(type, ...) "{{{3
+ let commentMode = a:0 >= 1 ? a:1 : ''
+ let bang = a:0 >= 2 ? a:2 : ''
+ if !exists('w:tcommentPos')
+ let w:tcommentPos = getpos(".")
+ endif
+ let sel_save = &selection
+ let &selection = "inclusive"
+ let reg_save = @@
+ " let pos = getpos('.')
+ " TLogVAR a:type
+ try
+ if a:type == 'line'
+ silent exe "normal! '[V']"
+ let commentMode1 = 'G'
+ elseif a:type == 'block'
+ silent exe "normal! `[\<C-V>`]"
+ let commentMode1 = 'I'
+ else
+ silent exe "normal! `[v`]"
+ let commentMode1 = 'i'
+ endif
+ if empty(commentMode)
+ let commentMode = commentMode1
+ endif
+ let beg = line("'[")
+ let end = line("']")
+ norm! 
+ let commentMode .= g:tcommentOpModeExtra
+ call tcomment#Comment(beg, end, commentMode.'o', bang)
+ finally
+ let &selection = sel_save
+ let @@ = reg_save
+ if g:tcommentOpModeExtra !~ '>'
+ " TLogVAR pos
+ " call setpos('.', pos)
+ call setpos('.', w:tcommentPos)
+ unlet! w:tcommentPos
+ endif
+ endtry
+endf
+
+
+function! tcomment#OperatorLine(type) "{{{3
+ call tcomment#Operator(a:type, 'G')
+endf
+
+
+function! tcomment#OperatorAnyway(type) "{{{3
+ call tcomment#Operator(a:type, '', '!')
+endf
+
+
+function! tcomment#OperatorLineAnyway(type) "{{{3
+ call tcomment#Operator(a:type, 'G', '!')
+endf
+
+
+" comment text as if it were of a specific filetype
+function! tcomment#CommentAs(beg, end, commentAnyway, filetype, ...)
+ let ccount = a:0 >= 1 ? a:1 : 1
+ " TLogVAR ccount
+ if a:filetype =~ '_block$'
+ let commentMode = 'B'
+ let ft = substitute(a:filetype, '_block$', '', '')
+ elseif a:filetype =~ '_inline$'
+ let commentMode = 'I'
+ let ft = substitute(a:filetype, '_inline$', '', '')
+ else
+ let commentMode = 'G'
+ let ft = a:filetype
+ endif
+ let [cms, commentMode] = s:GetCommentString(a:beg, a:end, commentMode, ft)
+ let pre = substitute(cms, '%s.*$', '', '')
+ let pre = substitute(pre, '%%', '%', 'g')
+ let post = substitute(cms, '^.\{-}%s', '', '')
+ let post = substitute(post, '%%', '%', 'g')
+ if ccount > 1
+ let pre_l = matchlist(pre, '^\(\S\+\)\(.*\)$')
+ " TLogVAR pre_l
+ if !empty(get(pre_l, 1))
+ let pre = repeat(pre_l[1], ccount) . pre_l[2]
+ endif
+ let post_l = matchlist(post, '^\(\s*\)\(.\+\)$')
+ " TLogVAR post_l
+ if !empty(get(post_l, 2))
+ let post = post_l[1] . repeat(post_l[2], ccount)
+ endif
+ endif
+ keepjumps call tcomment#Comment(a:beg, a:end, commentMode, a:commentAnyway, pre, post)
+endf
+
+
+" ----------------------------------------------------------------
+" collect all variables matching ^tcomment_
+function! tcomment#CollectFileTypes()
+ if g:tcommentFileTypesDirty
+ redir => vars
+ silent let
+ redir END
+ let g:tcommentFileTypes = split(vars, '\n')
+ call filter(g:tcommentFileTypes, 'v:val =~ "tcomment_"')
+ call map(g:tcommentFileTypes, 'matchstr(v:val, ''tcomment_\zs\S\+'')')
+ call sort(g:tcommentFileTypes)
+ let g:tcommentFileTypesRx = '\V\^\('. join(g:tcommentFileTypes, '\|') .'\)\(\u\.\*\)\?\$'
+ let g:tcommentFileTypesDirty = 0
+ endif
+endf
+
+call tcomment#CollectFileTypes()
+
+" return a list of filetypes for which a tcomment_{&ft} is defined
+function! tcomment#FileTypes(ArgLead, CmdLine, CursorPos)
+ " TLogVAR a:ArgLead, a:CmdLine, a:CursorPos
+ call tcomment#CollectFileTypes()
+ let types = copy(g:tcommentFileTypes)
+ if index(g:tcommentFileTypes, &filetype) != -1
+ " TLogVAR &filetype
+ call insert(types, &filetype)
+ endif
+ if empty(a:ArgLead)
+ return types
+ else
+ return filter(types, 'v:val =~ ''\V''.a:ArgLead')
+ endif
+endf
+
+function! s:EncodeCommentPart(string)
+ return substitute(a:string, '%', '%%', 'g')
+endf
+
+" s:GetCommentString(beg, end, commentMode, ?filetype="")
+function! s:GetCommentString(beg, end, commentMode, ...)
+ let ft = a:0 >= 1 ? a:1 : ''
+ if ft != ''
+ let [cms, commentMode] = s:GetCustomCommentString(ft, a:commentMode)
+ else
+ let cms = ''
+ let commentMode = a:commentMode
+ endif
+ if empty(cms)
+ if exists('b:commentstring')
+ let cms = b:commentstring
+ return s:GetCustomCommentString(&filetype, a:commentMode, cms)
+ elseif exists('b:commentStart') && b:commentStart != ''
+ let cms = s:EncodeCommentPart(b:commentStart) .' %s'
+ if exists('b:commentEnd') && b:commentEnd != ''
+ let cms = cms .' '. s:EncodeCommentPart(b:commentEnd)
+ endif
+ return s:GetCustomCommentString(&filetype, a:commentMode, cms)
+ elseif g:tcommentGuessFileType || (exists('g:tcommentGuessFileType_'. &filetype)
+ \ && g:tcommentGuessFileType_{&filetype} =~ '[^0]')
+ if g:tcommentGuessFileType_{&filetype} == 1
+ let altFiletype = ''
+ else
+ let altFiletype = g:tcommentGuessFileType_{&filetype}
+ endif
+ return s:GuessFileType(a:beg, a:end, a:commentMode, &filetype, altFiletype)
+ else
+ return s:GetCustomCommentString(&filetype, a:commentMode, s:GuessCurrentCommentString(a:commentMode))
+ endif
+ endif
+ return [cms, commentMode]
+endf
+
+" s:SPrintF(formatstring, ?values ...)
+" => string
+function! s:SPrintF(string, ...)
+ let n = 1
+ let r = ''
+ let s = a:string
+ while 1
+ let i = match(s, '%\(.\)')
+ if i >= 0
+ let x = s[i + 1]
+ let r = r . strpart(s, 0, i)
+ let s = strpart(s, i + 2)
+ if x == '%'
+ let r = r.'%'
+ else
+ if a:0 >= n
+ let v = a:{n}
+ let n = n + 1
+ else
+ echoerr 'Malformed format string (too many arguments required): '. a:string
+ endif
+ if x ==# 's'
+ let r = r.v
+ elseif x ==# 'S'
+ let r = r.'"'.v.'"'
+ else
+ echoerr 'Malformed format string: '. a:string
+ endif
+ endif
+ else
+ return r.s
+ endif
+ endwh
+endf
+
+function! s:StartRx(pos)
+ if a:pos == 0
+ return '\^'
+ else
+ return '\%'. a:pos .'c'
+ endif
+endf
+
+function! s:EndRx(pos)
+ if a:pos == 0
+ return '\$'
+ else
+ return '\%'. a:pos .'c'
+ endif
+endf
+
+function! s:GetIndentString(line, start)
+ let start = a:start > 0 ? a:start - 1 : 0
+ return substitute(strpart(getline(a:line), start), '\V\^\s\*\zs\.\*\$', '', '')
+endf
+
+function! s:CommentDef(beg, end, checkRx, commentMode, cstart, cend)
+ let mdrx = '\V'. s:StartRx(a:cstart) .'\s\*'. a:checkRx .'\s\*'. s:EndRx(0)
+ let line = getline(a:beg)
+ if a:cstart != 0 && a:cend != 0
+ let line = strpart(line, 0, a:cend - 1)
+ endif
+ let uncomment = (line =~ mdrx)
+ let it = s:GetIndentString(a:beg, a:cstart)
+ let il = indent(a:beg)
+ let n = a:beg + 1
+ while n <= a:end
+ if getline(n) =~ '\S'
+ let jl = indent(n)
+ if jl < il
+ let it = s:GetIndentString(n, a:cstart)
+ let il = jl
+ endif
+ if a:commentMode =~# 'G'
+ if !(getline(n) =~ mdrx)
+ let uncomment = 0
+ endif
+ endif
+ endif
+ let n = n + 1
+ endwh
+ if a:commentMode =~# 'B'
+ let t = @t
+ try
+ silent exec 'norm! '. a:beg.'G1|v'.a:end.'G$"ty'
+ let uncomment = (@t =~ mdrx)
+ finally
+ let @t = t
+ endtry
+ endif
+ return [it, uncomment]
+endf
+
+function! s:ProcessedLine(uncomment, match, checkRx, replace)
+ if !(a:match =~ '\S' || g:tcommentBlankLines)
+ return a:match
+ endif
+ let ml = len(a:match)
+ if a:uncomment
+ let rv = substitute(a:match, a:checkRx, '\1\2', '')
+ else
+ let rv = s:SPrintF(a:replace, a:match)
+ endif
+ " let md = len(rv) - ml
+ let s:pos_end = getpos('.')
+ let s:pos_end[2] += len(rv)
+ " TLogVAR pe, md, a:match
+ let rv = escape(rv, '\
+')
+ let rv = substitute(rv, '\n', '\\\n', 'g')
+ return rv
+endf
+
+function! s:CommentLines(beg, end, cstart, cend, uncomment, cmtCheck, cms0, indentStr) "{{{3
+ " We want commented lines
+ " final search pattern for uncommenting
+ let cmtCheck = escape('\V\^\(\s\{-}\)'. a:cmtCheck .'\$', '"/\')
+ " final pattern for commenting
+ let cmtReplace = escape(a:cms0, '"/')
+ silent exec a:beg .','. a:end .'s/\V'.
+ \ s:StartRx(a:cstart) . a:indentStr .'\zs\(\.\{-}\)'. s:EndRx(a:cend) .'/'.
+ \ '\=s:ProcessedLine('. a:uncomment .', submatch(0), "'. a:cmtCheck .'", "'. cmtReplace .'")/ge'
+endf
+
+function! s:CommentBlock(beg, end, uncomment, checkRx, replace, indentStr)
+ let t = @t
+ try
+ silent exec 'norm! '. a:beg.'G1|v'.a:end.'G$"td'
+ let ms = s:BlockGetMiddleString(a:replace)
+ let mx = escape(ms, '\')
+ if a:uncomment
+ let @t = substitute(@t, '\V\^\s\*'. a:checkRx .'\$', '\1', '')
+ if ms != ''
+ let @t = substitute(@t, '\V\n'. a:indentStr . mx, '\n'. a:indentStr, 'g')
+ endif
+ let @t = substitute(@t, '^\n', '', '')
+ let @t = substitute(@t, '\n\s*$', '', '')
+ else
+ let cs = s:BlockGetCommentString(a:replace)
+ let cs = a:indentStr . substitute(cs, '%s', '%s'. a:indentStr, '')
+ if ms != ''
+ let ms = a:indentStr . ms
+ let mx = a:indentStr . mx
+ let @t = substitute(@t, '^'. a:indentStr, '', 'g')
+ let @t = ms . substitute(@t, '\n'. a:indentStr, '\n'. mx, 'g')
+ endif
+ let @t = s:SPrintF(cs, "\n". @t ."\n")
+ endif
+ silent norm! "tP
+ finally
+ let @t = t
+ endtry
+endf
+
+" inspired by Meikel Brandmeyer's EnhancedCommentify.vim
+" this requires that a syntax names are prefixed by the filetype name
+" s:GuessFileType(beg, end, commentMode, filetype, ?fallbackFiletype)
+function! s:GuessFileType(beg, end, commentMode, filetype, ...)
+ if a:0 >= 1 && a:1 != ''
+ let [cms, commentMode] = s:GetCustomCommentString(a:1, a:commentMode)
+ if cms == ''
+ let cms = s:GuessCurrentCommentString(a:commentMode)
+ endif
+ else
+ let commentMode = s:CommentMode(a:commentMode, 'G')
+ let cms = s:GuessCurrentCommentString(0)
+ endif
+ let n = a:beg
+ " TLogVAR n, a:beg, a:end
+ while n <= a:end
+ let m = indent(n) + 1
+ let le = len(getline(n))
+ " TLogVAR m, le
+ while m < le
+ let syntaxName = synIDattr(synID(n, m, 1), 'name')
+ " TLogVAR syntaxName, n, m
+ let ftypeMap = get(g:tcommentSyntaxMap, syntaxName)
+ if !empty(ftypeMap)
+ " TLogVAR ftypeMap
+ return s:GetCustomCommentString(ftypeMap, a:commentMode, cms)
+ elseif syntaxName =~ g:tcommentFileTypesRx
+ let ft = substitute(syntaxName, g:tcommentFileTypesRx, '\1', '')
+ " TLogVAR ft
+ if exists('g:tcommentIgnoreTypes_'. a:filetype) && g:tcommentIgnoreTypes_{a:filetype} =~ '\<'.ft.'\>'
+ let m += 1
+ else
+ return s:GetCustomCommentString(ft, a:commentMode, cms)
+ endif
+ elseif syntaxName == '' || syntaxName == 'None' || syntaxName =~ '^\u\+$' || syntaxName =~ '^\u\U*$'
+ let m += 1
+ else
+ break
+ endif
+ endwh
+ let n += 1
+ endwh
+ return [cms, commentMode]
+endf
+
+function! s:CommentMode(commentMode, newmode) "{{{3
+ return substitute(a:commentMode, '\w\+', a:newmode, 'g')
+endf
+
+function! s:GuessCurrentCommentString(commentMode)
+ let valid_cms = (stridx(&commentstring, '%s') != -1)
+ if &commentstring != s:defaultCommentString && valid_cms
+ " The &commentstring appears to have been set and to be valid
+ return &commentstring
+ endif
+ if &comments != s:defaultComments
+ " the commentstring is the default one, so we assume that it wasn't
+ " explicitly set; we then try to reconstruct &cms from &comments
+ let cms = s:ConstructFromComments(a:commentMode)
+ if cms != s:nullCommentString
+ return cms
+ endif
+ endif
+ if valid_cms
+ " Before &commentstring appeared not to be set. As we don't know
+ " better we return it anyway if it is valid
+ return &commentstring
+ else
+ " &commentstring is invalid. So we return the identity string.
+ return s:nullCommentString
+ endif
+endf
+
+function! s:ConstructFromComments(commentMode)
+ exec s:ExtractCommentsPart('')
+ if a:commentMode =~# 'G' && line != ''
+ return line .' %s'
+ endif
+ exec s:ExtractCommentsPart('s')
+ if s != ''
+ exec s:ExtractCommentsPart('e')
+ " if a:commentMode
+ " exec s:ExtractCommentsPart("m")
+ " if m != ""
+ " let m = "\n". m
+ " endif
+ " return s.'%s'.e.m
+ " else
+ return s.' %s '.e
+ " endif
+ endif
+ if line != ''
+ return line .' %s'
+ else
+ return s:nullCommentString
+ endif
+endf
+
+function! s:ExtractCommentsPart(key)
+ " let key = a:key != "" ? a:key .'[^:]*' : ""
+ let key = a:key . '[bnflrxO0-9-]*'
+ let val = substitute(&comments, '^\(.\{-},\)\{-}'. key .':\([^,]\+\).*$', '\2', '')
+ if val == &comments
+ let val = ''
+ else
+ let val = substitute(val, '%', '%%', 'g')
+ endif
+ let var = a:key == '' ? 'line' : a:key
+ return 'let '. var .'="'. escape(val, '"') .'"'
+endf
+
+" s:GetCustomCommentString(ft, commentMode, ?default="")
+function! s:GetCustomCommentString(ft, commentMode, ...)
+ let commentMode = a:commentMode
+ let customComment = exists('g:tcomment_'. a:ft)
+ if commentMode =~# 'B' && exists('g:tcomment_'. a:ft .'_block')
+ let cms = g:tcomment_{a:ft}_block
+ elseif commentMode =~? 'I' && exists('g:tcomment_'. a:ft .'_inline')
+ let cms = g:tcomment_{a:ft}_inline
+ elseif customComment
+ let cms = g:tcomment_{a:ft}
+ let commentMode = s:CommentMode(commentMode, 'G')
+ elseif a:0 >= 1
+ let cms = a:1
+ let commentMode = s:CommentMode(commentMode, 'G')
+ else
+ let cms = ''
+ let commentMode = s:CommentMode(commentMode, 'G')
+ endif
+ return [cms, commentMode]
+endf
+
+function! s:BlockGetCommentString(cms)
+ " return substitute(a:cms, '\n.*$', '', '')
+ return matchstr(a:cms, '^.\{-}\ze\(\n\|$\)')
+endf
+
+function! s:BlockGetMiddleString(cms)
+ " let rv = substitute(a:cms, '^.\{-}\n\([^\n]*\)', '\1', '')
+ let rv = matchstr(a:cms, '\n\zs.*')
+ return rv == a:cms ? '' : rv
+endf
+
+
+redraw
View
208 vim/doc/tComment.txt
@@ -0,0 +1,208 @@
+*tComment.txt* tComment -- An easily extensible & universal comment plugin
+
+Author: Thomas Link, micathom AT gmail com?subject=vim
+
+tComment provides easy to use, file-type sensible comments for Vim. It
+can handle embedded syntax.
+
+
+ *tComment-Installation*
+Installation~
+Edit the vba file and type:
+
+ :so %
+
+See :help vimball for details. If you use vim 7.0, you may need to
+update your vimball installation first.
+
+
+ *tComment-Usage*
+Usage~
+TComment works like a toggle, i.e., it will comment out text that
+contains uncommented lines, and it will remove comment markup for
+already commented text (i.e. text that contains no uncommented lines).
+
+If the file-type is properly defined, TComment will figure out which
+comment string to use. Otherwise you use |TCommentDefineType()| to
+override the default choice.
+
+TComment can properly handle an embedded syntax, e.g., ruby/python/perl
+regions in vim scripts, HTML or JavaScript in php code etc.
+
+
+ *tComment-Key-Bindings*
+Key bindings~
+
+Most of the time the default toggle keys will do what you want (or to be
+more precise: what I think you want it to do ;-).
+
+ *g:tcommentMapLeaderOp1*
+ *g:tcommentMapLeaderOp2*
+As operator (the prefix can be customized via g:tcommentMapLeaderOp1
+and g:tcommentMapLeaderOp2):
+
+ gc{motion} :: Toggle comments (for small comments within one line
+ the &filetype_inline style will be used, if
+ defined)
+ gcc :: Toggle comment for the current line
+ gC{motion} :: Comment region
+ gCc :: Comment the current line
+
+ *g:tcommentOpModeExtra*
+By default the cursor stays put. If you want the cursor to the end of
+the commented text, set g:tcommentOpModeExtra to '>' (but this may not
+work properly with exclusive motions).
+
+Primary key maps:
+
+ <c-_><c-_> :: :TComment
+ <c-_><space> :: :TComment <QUERY COMMENT-BEGIN ?COMMENT-END>
+ <c-_>b :: :TCommentBlock
+ <c-_>a :: :TCommentAs <QUERY COMMENT TYPE>
+ <c-_>n :: :TCommentAs &filetype <QUERY COUNT>
+ <c-_>s :: :TCommentAs &filetype_<QUERY COMMENT SUBTYPE>
+ <c-_>i :: :TCommentInline
+ <c-_>r :: :TCommentRight
+ <c-_>p :: Comment the current inner paragraph
+
+A secondary set of key maps is defined for normal mode.
+
+ <Leader>__ :: :TComment
+ <Leader>_p :: Comment the current inner paragraph
+ <Leader>_<space> :: :TComment <QUERY COMMENT-BEGIN ?COMMENT-END>
+ <Leader>_i :: :TCommentInline
+ <Leader>_r :: :TCommentRight
+ <Leader>_b :: :TCommentBlock
+ <Leader>_a :: :TCommentAs <QUERY COMMENT TYPE>
+ <Leader>_n :: :TCommentAs &filetype <QUERY COUNT>
+ <Leader>_s :: :TCommentAs &filetype_<QUERY COMMENT SUBTYPE>
+
+Keymaps are configurable via the following variables:
+
+ *g:tcommentMapLeader1*
+g:tcommentMapLeader1 string (default: <c-_>)
+ Prefix for the keymaps. Set to '' to disable keymaps with this
+ prefix.
+ *g:tcommentMapLeader2*
+g:tcommentMapLeader2 string (default: <Leader>_)
+ Secondary prefix. (The reason for why there are two prefixes is
+ that <c-_> appears preferable with gvim but can be difficult to
+ type on the terminal. The secondary prefix isn't used for insert
+ mode maps. Set to '' to disable keymaps with this prefix.
+
+ *tComment-commands*
+Alternatively, you can type (? meaning "optional argument"):
+
+ *:TComment*
+ :?<range> TComment ?commentBegin ?commentEnd
+ :?<range> TComment! ?commentBegin ?commentEnd
+ NOTE: If there is a visual selection that begins and ends in the same
+ line, then TCommentInline is used instead.
+
+ NOTE: The range is optional and defaults to the current line.
+
+ *:TCommentInline*
+ :?<range> TCommentInline ?commentBegin ?commentEnd
+ :?<range> TCommentInline! ?commentBegin ?commentEnd
+ Use the {&ft}_inline comment style.
+
+ *:TCommentBlock*
+ :?<range> TCommentBlock ?commentBegin ?commentEnd
+ :?<range> TCommentBlock! ?commentBegin ?commentEnd
+ Comment as "block", e.g. use the {&ft}_block comment style.
+ NOTE: This command is kind of crude. It doesn't indent or reformat
+ the text.
+
+ *:TCommentAs*
+ :?<range> TCommentAs filetype
+ :?<range> TCommentAs! filetype
+ NOTE: TCommentAs requires g:tcomment_{filetype} to be defined.
+ NOTE: This command supports command line completion. See 'wildmode'
+ and 'wildmenu' for how to get the most out of it.
+
+ *:TCommentRight*
+ :?<range> TCommentRight
+ :?<range> TCommentRight!
+ NOTE: This command comments out the text to the right of the cursor.
+ If a visual selection was made (be it block-wise or not), all lines
+ are commented out at from the current cursor position downwards.
+
+ The bang (!) variants always comment out the selected text and don't
+ work as toggles.
+
+ *TCommentDefineType()*
+ Using this command you can also use different comment styles with
+ the TCommentDefineType(name, commentstring) function. This function
+ takes two arguments:
+ name :: The name is either &filetype or {&filetype}_{style}.
+ I.e., For block comments the {&filetype}_block and for
+ inline comments the {&filetype}_inline styles are used.
+ comment string :: a string mostly as described in
+ 'commentstring'.
+
+ If you want to define, e.g., a fancy block comment style for html
+ you put something like this into ~/.vim/after/plugin/tComment.vim:>
+
+ call TCommentDefineType("html_fancy_block", "<!--%s -->\n -- ")
+
+< The part after the newline character is used for marking "middle"
+ lines.
+
+ This comment style could then be accessed via (this command has
+ command line completion): >
+
+ '<,'>TCommentAs html_fancy_block
+
+< If you're editing a html file, this could best be done by the <c-_>s
+ key map.
+
+
+Goals~
+- Maintain indentation of selected text; the comment markers are left
+ aligned but the text on the right (i.e., the comment) is indented
+ like the original text
+
+- Handle embedded syntax like php+html or html+javaScript+css; you
+ have to set g:tcommentGuessFileType_{&filetype} to 1 or to the
+ fall-back file-type in order to activate this feature for other file
+ types than php or html
+
+ tComment deduces the correct file type from the syntax name, similar
+ to the way EnhancedCommentify.vim does it. In opposition to
+ EnhancedCommentify.vim, it matches the syntax name against a list the
+ known file types, so that it can deal with, e.g., embedded javaScript
+
+- Easy to customize/adapt for an yet unknown syntax by setting buffer
+ local variables (b:commentStart, b:commentEnd, or b:commentstring),
+ global variables (g:tcomment_{&ft} and g:tcomment_{&ft}_block), or the
+ buffer local &commentstring option (which can be set on a vim
+ |modeline|)
+
+- Use 'commentstring' or 'comments' as a fallback (i.e., if a file-type
+ is properly defined, TComment will automatically support it)
+
+- Same short-cut for commenting text and for removing comment markup
+
+- The decision whether text should be commented or uncommented is made
+ on the basis of the whole selection (not line by line); comments in
+ code that should be commented aren't uncommented as it is the case
+ with some other plug-ins
+
+As of version 1.5, the following file types are explicitly defined
+(other file-types are most likely supported through the 'commentstring'
+or 'comments' variables):
+
+ ada, apache, autoit, catalog, cpp, css, c, cfg, conf, desktop,
+ docbk, dosbatch, dosini, dsl, dylan, eiffel, gtkrc, haskell, html,
+ io, javaScript, java, lisp, m4, nroff, objc, ocaml, pascal, perl,
+ php, prolog, ruby, r, scheme, sgml, sh, sql, spec, sps, tcl, tex,
+ tpl, viki, vim, websec, xml, xslt, yaml
+
+
+Credits~
+The way we check for embedded syntax was originally adapted
+from/inspired by Meikel Brandmeyer's EnhancedCommentify.vim
+(vimscript #23) but has evolved since.
+
+
+vim: tw=72
View
16 vim/doc/tags
@@ -49,6 +49,11 @@
:NERDTreeFromBookmark NERD_tree.txt /*:NERDTreeFromBookmark*
:NERDTreeMirror NERD_tree.txt /*:NERDTreeMirror*
:NERDTreeToggle NERD_tree.txt /*:NERDTreeToggle*
+:TComment tComment.txt /*:TComment*
+:TCommentAs tComment.txt /*:TCommentAs*
+:TCommentBlock tComment.txt /*:TCommentBlock*
+:TCommentInline tComment.txt /*:TCommentInline*
+:TCommentRight tComment.txt /*:TCommentRight*
ExtractSnips() snipMate.txt /*ExtractSnips()*
ExtractSnipsFile() snipMate.txt /*ExtractSnipsFile()*
Filename() snipMate.txt /*Filename()*
@@ -112,6 +117,7 @@ NERDTreeOptions NERD_tree.txt /*NERDTreeOptions*
NERDTreeRender() NERD_tree.txt /*NERDTreeRender()*
NERD_tree.txt NERD_tree.txt /*NERD_tree.txt*
ResetSnippets() snipMate.txt /*ResetSnippets()*
+TCommentDefineType() tComment.txt /*TCommentDefineType()*
abc fuf.txt /*abc*
config/rails.vim rails.txt /*config\/rails.vim*
cs surround.txt /*cs*
@@ -252,6 +258,11 @@ g:rails_tabstop rails.txt /*g:rails_tabstop*
g:rails_url rails.txt /*g:rails_url*
g:snippets_dir snipMate.txt /*g:snippets_dir*
g:snips_author snipMate.txt /*g:snips_author*
+g:tcommentMapLeader1 tComment.txt /*g:tcommentMapLeader1*
+g:tcommentMapLeader2 tComment.txt /*g:tcommentMapLeader2*
+g:tcommentMapLeaderOp1 tComment.txt /*g:tcommentMapLeaderOp1*
+g:tcommentMapLeaderOp2 tComment.txt /*g:tcommentMapLeaderOp2*
+g:tcommentOpModeExtra tComment.txt /*g:tcommentOpModeExtra*
i_CTRL-G_S surround.txt /*i_CTRL-G_S*
i_CTRL-G_s surround.txt /*i_CTRL-G_s*
i_CTRL-R_<Tab> snipMate.txt /*i_CTRL-R_<Tab>*
@@ -448,6 +459,11 @@ surround-mappings surround.txt /*surround-mappings*
surround-replacements surround.txt /*surround-replacements*
surround-targets surround.txt /*surround-targets*
surround.txt surround.txt /*surround.txt*
+tComment-Installation tComment.txt /*tComment-Installation*
+tComment-Key-Bindings tComment.txt /*tComment-Key-Bindings*
+tComment-Usage tComment.txt /*tComment-Usage*
+tComment-commands tComment.txt /*tComment-commands*
+tComment.txt tComment.txt /*tComment.txt*
vs surround.txt /*vs*
yS surround.txt /*yS*
ySS surround.txt /*ySS*
View
27 vim/plugin/Rename.vim
@@ -0,0 +1,27 @@
+" Rename.vim - Rename a buffer within Vim and on the disk
+"
+" Copyright June 2007 by Christian J. Robinson <infynity@onewest.net>
+"
+" Distributed under the terms of the Vim license. See ":help license".
+"
+" Usage:
+"
+" :Rename[!] {newname}
+
+command! -nargs=* -complete=file -bang Rename :call Rename("<args>", "<bang>")
+
+function! Rename(name, bang)
+ let l:curfile = expand("%:p")
+ let v:errmsg = ""
+ silent! exe "saveas" . a:bang . " " . a:name
+ if v:errmsg =~# '^$\|^E329'
+ if expand("%:p") !=# l:curfile && filewritable(expand("%:p"))
+ silent exe "bwipe! " . l:curfile
+ if delete(l:curfile)
+ echoerr "Could not delete " . l:curfile
+ endif
+ endif
+ else
+ echoerr v:errmsg
+ endif
+endfunction
View
385 vim/plugin/tComment.vim
@@ -0,0 +1,385 @@
+" tComment.vim -- An easily extensible & universal comment plugin
+" @Author: Tom Link (micathom AT gmail com)
+" @License: GPL (see http://www.gnu.org/licenses/gpl.txt)
+" @Created: 27-Dez-2004.
+" @Last Change: 2009-08-07.
+" @Revision: 1.9.671
+"
+" GetLatestVimScripts: 1173 1 tComment.vim
+
+if &cp || exists('loaded_tcomment')
+ finish
+endif
+let loaded_tcomment = 109
+
+" If true, comment blank lines too
+if !exists("g:tcommentBlankLines")
+ let g:tcommentBlankLines = 1
+endif
+
+if !exists("g:tcommentMapLeader1")
+ let g:tcommentMapLeader1 = '<c-_>'
+endif
+if !exists("g:tcommentMapLeader2")
+ let g:tcommentMapLeader2 = '<Leader>_'
+endif
+if !exists("g:tcommentMapLeaderOp1")
+ let g:tcommentMapLeaderOp1 = 'gc'
+endif
+if !exists("g:tcommentMapLeaderOp2")
+ let g:tcommentMapLeaderOp2 = 'gC'
+endif
+if !exists("g:tcommentOpModeExtra")
+ let g:tcommentOpModeExtra = ''
+endif
+
+" Guess the file type based on syntax names always or for some fileformat only
+if !exists("g:tcommentGuessFileType")
+ let g:tcommentGuessFileType = 0
+endif
+" In php documents, the php part is usually marked as phpRegion. We thus
+" assume that the buffers default comment style isn't php but html
+if !exists("g:tcommentGuessFileType_dsl")
+ let g:tcommentGuessFileType_dsl = 'xml'
+endif
+if !exists("g:tcommentGuessFileType_php")
+ let g:tcommentGuessFileType_php = 'html'
+endif
+if !exists("g:tcommentGuessFileType_html")
+ let g:tcommentGuessFileType_html = 1
+endif
+if !exists("g:tcommentGuessFileType_tskeleton")
+ let g:tcommentGuessFileType_tskeleton = 1
+endif
+if !exists("g:tcommentGuessFileType_vim")
+ let g:tcommentGuessFileType_vim = 1
+endif
+
+if !exists("g:tcommentIgnoreTypes_php")
+ let g:tcommentIgnoreTypes_php = 'sql'
+endif
+
+if !exists('g:tcommentSyntaxMap') "{{{2
+ let g:tcommentSyntaxMap = {
+ \ 'vimMzSchemeRegion': 'scheme',
+ \ 'vimPerlRegion': 'perl',
+ \ 'vimPythonRegion': 'python',
+ \ 'vimRubyRegion': 'ruby',
+ \ 'vimTclRegion': 'tcl',
+ \ }
+endif
+
+" If you don't define these variables, TComment will use &commentstring
+" instead. We override the default values here in order to have a blank after
+" the comment marker. Block comments work only if we explicitly define the
+" markup.
+" The format for block comments is similar to normal commentstrings with the
+" exception that the format strings for blocks can contain a second line that
+" defines how "middle lines" (see :h format-comments) should be displayed.
+
+" I personally find this style rather irritating but here is an alternative
+" definition that does this left-handed bar thing
+if !exists("g:tcommentBlockC")
+ let g:tcommentBlockC = "/*%s */\n * "
+endif
+if !exists("g:tcommentBlockC2")
+ let g:tcommentBlockC2 = "/**%s */\n * "
+endif
+if !exists("g:tcommentInlineC")
+ let g:tcommentInlineC = "/* %s */"
+endif
+
+if !exists("g:tcommentBlockXML")
+ let g:tcommentBlockXML = "<!--%s-->\n "
+endif
+if !exists("g:tcommentInlineXML")
+ let g:tcommentInlineXML = "<!-- %s -->"
+endif
+
+let g:tcommentFileTypesDirty = 1
+
+" Currently this function just sets a variable
+function! TCommentDefineType(name, commentstring)
+ if !exists('g:tcomment_'. a:name)
+ let g:tcomment_{a:name} = a:commentstring
+ endif
+ let g:tcommentFileTypesDirty = 1
+endf
+
+function! TCommentTypeExists(name)
+ return exists('g:tcomment_'. a:name)
+endf
+
+call TCommentDefineType('aap', '# %s' )
+call TCommentDefineType('ada', '-- %s' )
+call TCommentDefineType('apache', '# %s' )
+call TCommentDefineType('autoit', '; %s' )
+call TCommentDefineType('asm', '; %s' )
+call TCommentDefineType('awk', '# %s' )
+call TCommentDefineType('catalog', '-- %s --' )
+call TCommentDefineType('catalog_block', "--%s--\n " )
+call TCommentDefineType('cpp', '// %s' )
+call TCommentDefineType('cpp_inline', g:tcommentInlineC )
+call TCommentDefineType('cpp_block', g:tcommentBlockC )
+call TCommentDefineType('css', '/* %s */' )
+call TCommentDefineType('css_inline', g:tcommentInlineC )
+call TCommentDefineType('css_block', g:tcommentBlockC )
+call TCommentDefineType('c', '/* %s */' )
+call TCommentDefineType('c_inline', g:tcommentInlineC )
+call TCommentDefineType('c_block', g:tcommentBlockC )
+call TCommentDefineType('cfg', '# %s' )
+call TCommentDefineType('conf', '# %s' )
+call TCommentDefineType('crontab', '# %s' )
+call TCommentDefineType('desktop', '# %s' )
+call TCommentDefineType('docbk', '<!-- %s -->' )
+call TCommentDefineType('docbk_inline', g:tcommentInlineXML)
+call TCommentDefineType('docbk_block', g:tcommentBlockXML )
+call TCommentDefineType('dosbatch', 'rem %s' )
+call TCommentDefineType('dosini', '; %s' )
+call TCommentDefineType('dsl', '; %s' )
+call TCommentDefineType('dylan', '// %s' )
+call TCommentDefineType('eiffel', '-- %s' )
+call TCommentDefineType('eruby', '<%%# %s%%>' )
+call TCommentDefineType('gtkrc', '# %s' )
+call TCommentDefineType('gitcommit', '# %s' )
+call TCommentDefineType('haskell', '-- %s' )
+call TCommentDefineType('haskell_block', "{-%s-}\n " )
+call TCommentDefineType('haskell_inline', '{- %s -}' )
+call TCommentDefineType('html', '<!-- %s -->' )
+call TCommentDefineType('html_inline', g:tcommentInlineXML)
+call TCommentDefineType('html_block', g:tcommentBlockXML )
+call TCommentDefineType('io', '// %s' )
+call TCommentDefineType('javaScript', '// %s' )
+call TCommentDefineType('javaScript_inline', g:tcommentInlineC )
+call TCommentDefineType('javaScript_block', g:tcommentBlockC )
+call TCommentDefineType('javascript', '// %s' )
+call TCommentDefineType('javascript_inline', g:tcommentInlineC )
+call TCommentDefineType('javascript_block', g:tcommentBlockC )
+call TCommentDefineType('java', '/* %s */' )
+call TCommentDefineType('java_inline', g:tcommentInlineC )
+call TCommentDefineType('java_block', g:tcommentBlockC )
+call TCommentDefineType('java_doc_block', g:tcommentBlockC2 )
+call TCommentDefineType('jproperties', '# %s' )
+call TCommentDefineType('lisp', '; %s' )
+call TCommentDefineType('lynx', '# %s' )
+call TCommentDefineType('m4', 'dnl %s' )
+call TCommentDefineType('mail', '> %s' )
+call TCommentDefineType('msidl', '// %s' )
+call TCommentDefineType('msidl_block', g:tcommentBlockC )
+call TCommentDefineType('nroff', '.\\" %s' )
+call TCommentDefineType('nsis', '# %s' )
+call TCommentDefineType('objc', '/* %s */' )
+call TCommentDefineType('objc_inline', g:tcommentInlineC )
+call TCommentDefineType('objc_block', g:tcommentBlockC )
+call TCommentDefineType('ocaml', '(* %s *)' )
+call TCommentDefineType('ocaml_inline', '(* %s *)' )
+call TCommentDefineType('ocaml_block', "(*%s*)\n " )
+call TCommentDefineType('pascal', '(* %s *)' )
+call TCommentDefineType('pascal_inline', '(* %s *)' )
+call TCommentDefineType('pascal_block', "(*%s*)\n " )
+call TCommentDefineType('perl', '# %s' )
+call TCommentDefineType('perl_block', "=cut%s=cut" )
+call TCommentDefineType('php', '// %s' )
+call TCommentDefineType('php_inline', g:tcommentInlineC )
+call TCommentDefineType('php_block', g:tcommentBlockC )
+call TCommentDefineType('php_2_block', g:tcommentBlockC2 )
+call TCommentDefineType('po', '# %s' )
+call TCommentDefineType('prolog', '%% %s' )
+call TCommentDefineType('rc', '// %s' )
+call TCommentDefineType('readline', '# %s' )
+call TCommentDefineType('ruby', '# %s' )
+call TCommentDefineType('ruby_3', '### %s' )
+call TCommentDefineType('ruby_block', "=begin rdoc%s=end")
+call TCommentDefineType('ruby_nodoc_block', "=begin%s=end" )
+call TCommentDefineType('r', '# %s' )
+call TCommentDefineType('sbs', "' %s" )
+call TCommentDefineType('scheme', '; %s' )
+call TCommentDefineType('sed', '# %s' )
+call TCommentDefineType('sgml', '<!-- %s -->' )
+call TCommentDefineType('sgml_inline', g:tcommentInlineXML)
+call TCommentDefineType('sgml_block', g:tcommentBlockXML )
+call TCommentDefineType('sh', '# %s' )
+call TCommentDefineType('sql', '-- %s' )
+call TCommentDefineType('spec', '# %s' )
+call TCommentDefineType('sps', '* %s.' )
+call TCommentDefineType('sps_block', "* %s." )
+call TCommentDefineType('spss', '* %s.' )
+call TCommentDefineType('spss_block', "* %s." )
+call TCommentDefineType('tcl', '# %s' )
+call TCommentDefineType('tex', '%% %s' )
+call TCommentDefineType('tpl', '<!-- %s -->' )
+call TCommentDefineType('viki', '%% %s' )
+call TCommentDefineType('viki_3', '%%%%%% %s' )
+call TCommentDefineType('viki_inline', '{cmt: %s}' )
+call TCommentDefineType('vim', '" %s' )
+call TCommentDefineType('vim_3', '""" %s' )
+call TCommentDefineType('websec', '# %s' )
+call TCommentDefineType('xml', '<!-- %s -->' )
+call TCommentDefineType('xml_inline', g:tcommentInlineXML)
+call TCommentDefineType('xml_block', g:tcommentBlockXML )
+call TCommentDefineType('xs', '// %s' )
+call TCommentDefineType('xs_block', g:tcommentBlockC )
+call TCommentDefineType('xslt', '<!-- %s -->' )
+call TCommentDefineType('xslt_inline', g:tcommentInlineXML)
+call TCommentDefineType('xslt_block', g:tcommentBlockXML )
+call TCommentDefineType('yaml', '# %s' )
+
+
+" :line1,line2 TCommentAs commenttype
+command! -bang -complete=customlist,tcomment#FileTypes -range -nargs=+ TCommentAs
+ \ call tcomment#CommentAs(<line1>, <line2>, "<bang>", <f-args>)
+
+" :line1,line2 TComment ?commentBegin ?commentEnd
+command! -bang -range -nargs=* TComment keepjumps call tcomment#Comment(<line1>, <line2>, 'G', "<bang>", <f-args>)
+
+" :line1,line2 TCommentRight ?commentBegin ?commentEnd
+command! -bang -range -nargs=* TCommentRight keepjumps call tcomment#Comment(<line1>, <line2>, 'R', "<bang>", <f-args>)
+
+" :line1,line2 TCommentBlock ?commentBegin ?commentEnd
+command! -bang -range -nargs=* TCommentBlock keepjumps call tcomment#Comment(<line1>, <line2>, 'B', "<bang>", <f-args>)
+
+" :line1,line2 TCommentInline ?commentBegin ?commentEnd
+command! -bang -range -nargs=* TCommentInline keepjumps call tcomment#Comment(<line1>, <line2>, 'I', "<bang>", <f-args>)
+
+" :line1,line2 TCommentMaybeInline ?commentBegin ?commentEnd
+command! -bang -range -nargs=* TCommentMaybeInline keepjumps call tcomment#Comment(<line1>, <line2>, 'i', "<bang>", <f-args>)
+
+
+
+if (g:tcommentMapLeader1 != '')
+ exec 'noremap <silent> '. g:tcommentMapLeader1 .'<c-_> :TComment<cr>'
+ exec 'vnoremap <silent> '. g:tcommentMapLeader1 .'<c-_> :TCommentMaybeInline<cr>'
+ exec 'inoremap <silent> '. g:tcommentMapLeader1 .'<c-_> <c-o>:TComment<cr>'
+ exec 'noremap <silent> '. g:tcommentMapLeader1 .'p m`vip:TComment<cr>``'
+ exec 'inoremap <silent> '. g:tcommentMapLeader1 .'p <c-o>:norm! m`vip<cr>:TComment<cr><c-o>``'
+ exec 'noremap '. g:tcommentMapLeader1 .'<space> :TComment '
+ exec 'inoremap '. g:tcommentMapLeader1 .'<space> <c-o>:TComment '
+ exec 'inoremap <silent> '. g:tcommentMapLeader1 .'r <c-o>:TCommentRight<cr>'
+ exec 'noremap <silent> '. g:tcommentMapLeader1 .'r :TCommentRight<cr>'
+ exec 'vnoremap <silent> '. g:tcommentMapLeader1 .'i :TCommentInline<cr>'
+ exec 'vnoremap <silent> '. g:tcommentMapLeader1 .'r :TCommentRight<cr>'
+ exec 'noremap '. g:tcommentMapLeader1 .'b :TCommentBlock<cr>'
+ exec 'inoremap '. g:tcommentMapLeader1 .'b <c-o>:TCommentBlock<cr>'
+ exec 'noremap '. g:tcommentMapLeader1 .'a :TCommentAs '
+ exec 'inoremap '. g:tcommentMapLeader1 .'a <c-o>:TCommentAs '
+ exec 'noremap '. g:tcommentMapLeader1 .'n :TCommentAs <c-r>=&ft<cr> '
+ exec 'inoremap '. g:tcommentMapLeader1 .'n <c-o>:TCommentAs <c-r>=&ft<cr> '
+ exec 'noremap '. g:tcommentMapLeader1 .'s :TCommentAs <c-r>=&ft<cr>_'
+ exec 'inoremap '. g:tcommentMapLeader1 .'s <c-o>:TCommentAs <c-r>=&ft<cr>_'
+endif
+if (g:tcommentMapLeader2 != '')
+ exec 'noremap <silent> '. g:tcommentMapLeader2 .'_ :TComment<cr>'
+ exec 'vnoremap <silent> '. g:tcommentMapLeader2 .'_ :TCommentMaybeInline<cr>'
+ exec 'noremap <silent> '. g:tcommentMapLeader2 .'p vip:TComment<cr>'
+ exec 'noremap '. g:tcommentMapLeader2 .'<space> :TComment '
+ exec 'vnoremap <silent> '. g:tcommentMapLeader2 .'i :TCommentInline<cr>'
+ exec 'noremap <silent> '. g:tcommentMapLeader2 .'r :TCommentRight<cr>'
+ exec 'vnoremap <silent> '. g:tcommentMapLeader2 .'r :TCommentRight<cr>'
+ exec 'noremap '. g:tcommentMapLeader2 .'b :TCommentBlock<cr>'
+ exec 'noremap '. g:tcommentMapLeader2 .'a :TCommentAs '
+ exec 'noremap '. g:tcommentMapLeader2 .'n :TCommentAs <c-r>=&ft<cr> '
+ exec 'noremap '. g:tcommentMapLeader2 .'s :TCommentAs <c-r>=&ft<cr>_'
+endif
+if (g:tcommentMapLeaderOp1 != '')
+ exec 'nnoremap <silent> '. g:tcommentMapLeaderOp1 .' :let w:tcommentPos = getpos(".") \| set opfunc=tcomment#Operator<cr>g@'
+ exec 'nnoremap <silent> '. g:tcommentMapLeaderOp1 .'c :let w:tcommentPos = getpos(".") \| set opfunc=tcomment#OperatorLine<cr>g@$'
+ exec 'vnoremap <silent> '. g:tcommentMapLeaderOp1 .' :TCommentMaybeInline<cr>'
+endif
+if (g:tcommentMapLeaderOp2 != '')
+ exec 'nnoremap <silent> '. g:tcommentMapLeaderOp2 .' :let w:tcommentPos = getpos(".") \| set opfunc=tcomment#OperatorAnyway<cr>g@'
+ exec 'nnoremap <silent> '. g:tcommentMapLeaderOp2 .'c :let w:tcommentPos = getpos(".") \| set opfunc=tcomment#OperatorLineAnyway<cr>g@$'
+ exec 'vnoremap <silent> '. g:tcommentMapLeaderOp2 .' :TCommentMaybeInline<cr>'
+endif
+
+finish
+
+
+-----------------------------------------------------------------------
+History
+
+0.1
+- Initial release
+
+0.2
+- Fixed uncommenting of non-aligned comments
+- improved support for block comments (with middle lines and indentation)
+- using TCommentBlock for file types that don't have block comments creates
+single line comments
+- removed the TCommentAsBlock command (TCommentAs provides its functionality)
+- removed g:tcommentSetCMS
+- the default key bindings have slightly changed
+
+1.3
+- slightly improved recognition of embedded syntax
+- if no commentstring is defined in whatever way, reconstruct one from
+&comments
+- The TComment... commands now have bang variants that don't act as toggles
+but always comment out the selected text
+- fixed problem with commentstrings containing backslashes
+- comment as visual block (allows commenting text to the right of the main
+text, i.e., this command doesn't work on whole lines but on the text to the
+right of the cursor)
+- enable multimode for dsl, vim filetypes
+- added explicit support for some other file types I ran into
+
+1.4
+- Fixed problem when &commentstring was invalid (e.g. lua)
+- perl_block by Kyosuke Takayama.
+- <c-_>s mapped to :TCommentAs <c-r>=&ft<cr>
+
+1.5
+- "Inline" visual comments (uses the &filetype_inline style if
+available; doesn't check if the filetype actually supports this kind of
+comments); tComment can't currently deduce inline comment styles from
+&comments or &commentstring (I personally hardly ever use them); default
+map: <c-_>i or <c-_>I
+- In visual mode: if the selection spans several lines, normal mode is
+selected; if the selection covers only a part of one line, inline mode
+is selected
+- Fixed problem with lines containing ^M or ^@ characters.
+- It's no longer necessary to call TCommentCollectFileTypes() after
+defining a new filetype via TCommentDefineType()
+- Disabled single <c-_> mappings
+- Renamed TCommentVisualBlock to TCommentRight
+- FIX: Forgot 'x' in ExtractCommentsPart() (thanks to Fredrik Acosta)
+
+1.6
+- Ignore sql when guessing the comment string in php files; tComment
+sometimes chooses the wrong comment string because the use of sql syntax
+is used too loosely in php files; if you want to comment embedded sql
+code you have to use TCommentAs
+- Use keepjumps in commands.
+- Map <c-_>p & <L>_p to vip:TComment<cr>
+- Made key maps configurable via g:tcommentMapLeader1 and
+g:tcommentMapLeader2
+
+1.7
+- gc{motion} (see g:tcommentMapLeaderOp1) functions as a comment toggle
+operator (i.e., something like gcl... works, mostly); gC{motion} (see
+g:tcommentMapLeaderOp2) will unconditionally comment the text.
+- TCommentAs takes an optional second argument (the comment level)
+- New "n" map: TCommentAs &filetype [COUNT]
+- Defined mail comments/citations
+- g:tcommentSyntaxMap: Map syntax names to filetypes for buffers with
+mixed syntax groups that don't match the filetypeEmbeddedsyntax scheme (e.g.
+'vimRubyRegion', which should be commented as ruby syntax, not as vim
+syntax)
+- FIX: Comments in vim*Region
+- TComment: The use of the type argument has slightly changed (IG -> i,
+new: >)
+
+1.8
+- Definitly require vim7
+- Split the plugin into autoload & plugin.
+- g:TCommentFileTypes is a list
+- Fixed some block comment strings
+- Removed extraneous newline in some block comments.
+- Maps for visal mode (thanks Krzysztof Goj)
+
+1.9
+- Fix left offset for inline comments (via operator binding)
+
+1.10
+- tcomment#Operator defines w:tcommentPos if invoked repeatedly
+- s:GuessFileType: use len(getline()) instead of col()
+
View
25 vimrc
@@ -50,7 +50,7 @@ if has("autocmd")
au!
" For all text files set 'textwidth' to 78 characters.
- autocmd FileType text setlocal textwidth=78
+ " autocmd FileType text setlocal textwidth=78
" When editing a file, always jump to the last known cursor position.
" Don't do it when the position is invalid or when inside an event handler
@@ -119,20 +119,21 @@ map <Leader>e :e <C-R>=expand("%:p:h") . "/" <CR>
map <Leader>te :tabe <C-R>=expand("%:p:h") . "/" <CR>
" Move lines up and down
-map <Leader>> :m +1 <CR>
-map <Leader>< :m -2 <CR>
+map <C-J> :m +1 <CR>
+map <C-K> :m -2 <CR>
" Inserts the path of the currently edited file into a command
" Command mode: Ctrl+P
cmap <C-P> <C-R>=expand("%:p:h") . "/" <CR>
-" Maps autocomplete to tab
-imap <Tab> <C-N>
-
" Duplicate a selection
" Visual mode: D
vmap D y'>p
+" Press Shift+P while in visual mode to replace the selection without
+" overwriting the default register
+vmap P p :call setreg('"', getreg('0')) <CR>
+
" For Haml
au! BufRead,BufNewFile *.haml setfiletype haml
@@ -142,16 +143,17 @@ nmap <F1> <Esc>
" Press ^F from insert mode to insert the current file name
imap <C-F> <C-R>=expand("%")<CR>
-" Press Shift+P while in visual mode to replace the selection without
-" overwriting the default register
-vmap P p :call setreg('"', getreg('0')) <CR>
+" Maps autocomplete to tab
+imap <Tab> <C-N>
+
+imap <C-L> <Space>=><Space>
" Display extra whitespace
" set list listchars=tab:»·,trail:·
" Edit routes
command! Rroutes :e config/routes.rb
-command! RTroutes :tabe config/routes.rb
+command! Rschema :e db/schema.rb
" Local config
if filereadable(".vimrc.local")
@@ -160,7 +162,7 @@ endif
" Use Ack instead of Grep when available
if executable("ack")
- set grepprg=ack\ -H\ --nogroup\ --nocolor
+ set grepprg=ack\ -H\ --nogroup\ --nocolor\ --ignore-dir=tmp\ --ignore-dir=coverage
endif
" Color scheme
@@ -187,6 +189,7 @@ set smartcase
" Tags
let g:Tlist_Ctags_Cmd="ctags --exclude='*.js'"
+set tags=./tags;
let g:fuf_splitPathMatching=1

0 comments on commit 08fcef0

Please sign in to comment.
Something went wrong with that request. Please try again.