I noticed that fold texts can show useful information. They usually show something like
+-- 5 lines: <div id="header-inner">--------------------------------------------
Is it possible to change the text in those lines? I noticed that something is possible in foldexpr but would it be possible to completely redesign folds?
e.g.
+ <div id="header-inner"> : "possible comment from line above" : row 27 : length 5
thank you
There are a few things I don't understand from your question, such as which foldmethod you are using, or what the number of "rows" refers to, but here's a custom foldtext function that should do roughly what you want:
function! MyFoldText()
let nl = v:foldend - v:foldstart + 1
let comment = substitute(getline(v:foldstart),"^ *","",1)
let linetext = substitute(getline(v:foldstart+1),"^ *","",1)
let txt = '+ ' . linetext . ' : "' . comment . '" : length ' . nl
return txt
endfunction
set foldtext=MyFoldText()
Explanation:
Find the number of lines contained by the fold.
Get the "comment" from the line before the first folded line (and remove leading spaces).
Get the text from the first line of the fold (and remove leading spaces).
Assemble the above information into the returned foldtext, with appropriate formatting.
Hope this helps. It should be easily tailored to your needs.
You can also inspect the folding config from Steve Losh’s bitbucket repo page about vim.
It has very beautiful appearance, which is also very organized!
To see what it is like, you might ckeck it out in this youtube video.
Related
Hi so I am looking for a method for highlighting a subset of numbers in the LineNumber column of vim. Maybe highlight is a bad choice, it could be as simple as just changing the background/foreground color of specific numbers.
My example
.pdbrc
b ~/foo.py:3
b ~/foo.py:7
when I open foo.py in VIM I would like lines 3 and 7 to be highlighted or have a different background color than the rest of the line numbers.
Basically I am just looking for a way to visually tell me, in VIM, where I have breakpoints set up in a file as per my .pdbrc
From my searching I believe this is not possible, but I don't know how VIM works very well and as such I may be misinterpreting the stackoverflow posts I have read.
What I've got so far, this will return a list of line numbers from the .pdbrc how do I take this list of numbers and highlight them or change their background color conditionally in vimscript?
function! s:parse_pdbrc(cur_file_abs_path)
" read the .pdbrc lines and search for current in
let s:lines = readfile("~/.pdbrc")
" parse the filepath to make it regexable
let s:file = substitute(a:cur_file_abs_path, "/", "\/", "")
let s:file = substitute(s:file, ".", "\.", "")
let s:regex = join(['b\s+',s:file,':(\d+)'],'')
" make some storage
let s:alist = []
" iterate over the lines
for s:line in s:lines
" check if cur_file in line
let s:match = matchlist(s:line, s:regex)
" if we have a match store it
if !empty(s:match)
let s:alist = add(s:alist, s:match[1])
endif
endfor
return s:alist
endfunction
I am working in vim. I have a piece text that looks like :
one = 24
two = 52
three = 56
four = 74
Is there a way to use visual select to yank and paste up to the equal to sign in each line ? I want an operation that leaves me with the following result :
one = 24
two = 52
three = 56
four = 74
one =
two =
three =
four =
My current solution is to copy the whole thing, then jump to the one = 24 line in what I copied and then record this macro : 0f=ld$j to #w and then repeat it three times with 3#w. Is there a way to do this using visual select and yank and paste ?
I tend to use :substitute for these things
" First I yank and paste, in normal mode
yapP
" Then I transform
gv " to reselect, while in normal mode
:s/=.*/=/ " that will actual display :'<,'>s/.....
The actual reselection part may need a little work depending on where the cleared snippet shall appear. May be something like yapo<esc>p:'[,']s/=.*/=/ + enter
You can visually select the lines to apply normal commands to them with :norm.
Thus, you could do:
ggVG:norm f=ld$
How about
:global /=/ copy $ | substitute /=\zs.*//
We use global to select the original lines, then copy them to the end $ and remove the parts after = with substitute.
You could use a mapping like this
vnoremap ,s y:let #"=system('sed -nE "s/=.*/=/p"',#")<cr>
When selecting now some lines in in visual mode, type ,s. This will put the desired modification into the " register and you can paste them now using p wherever you want.
I know how to comment out multiple lines in VIM, but what if I wanted to add comments in the end of each line?
For example:
function dir.ls(path)
local i,files = 0,{}
local pfile = io.popen('ls "'..path..'"')
for fname in pfile:lines() do
i = i + 1
fpath = path..fname
files[i] = fpath
end
pfile:close()
return files
end
Now with added comments:
function dir.ls(path)
local i,files = 0,{}
local pfile = io.popen('ls "'..path..'"')
for fname in pfile:lines() do
i = i + 1
fpath = path..fname -- your comment goes here
files[i] = fpath -- your comment goes here
end
pfile:close() -- your comment goes here
return files
end
Append your comment to the first line:
A -- your comment goes here<Esc>
Move the cursor to the next line you want to add a comment to.
Repeat the last edit:
.
And so on…
In your example:
A -- your comment goes here<Esc>
j.
jj.
Another method, but in a single step:
:,+3v/end/norm A -- your comment goes here<CR>
That command is easier to understand if it is explained from right to left:
The :normal command allows you to execute a sequence of normal mode commands from command-line mode. Here, we use it to append the comment to the given line, just like in the first step of the multi-step method.
v/pattern/command is a companion to the :global command. It means "run the given command on every line in the given range that doesn't match pattern". Here, we run our :normal command on every line in the given range that doesn't contain end.
,+3 is the range of lines on which we want to run the :v command. It is a shortened version of .,+3 which means "the current line and the next three lines".
I am using ruby on rails but that does not matter much for this question. Let's say that i have a statement like this
error = 'this is an error message'
I have noticed that I end up doing this a lot
error = 'this is an error message'
puts "error = #{error.inspect}"
I am sure a macro can be written which would take the work on the left hand side of left most = and then create another line along with template shown above.
I am using mvim on mac. Any pointer in terms of where I should start to look for developing what I want.
Try snipmate:
http://www.vim.org/scripts/script.php?script_id=2540
I recorded a simple macro that does your sample. To record a macro type q followed by what register you want the macro to be put in (convention calls for qq). To play the macro type # then the macro register. You can view this at :help recording
To write the macro, use the following commands (and here is how is should look in the register)
^yEoputs "error = #{^Op.inspect}"^[
^ moves to the first non whitespace character of the line
yE yanks to the end of the space separated word.
o Puts you in insert mode on the next line
puts "error = #{ is the text that you type out
^O is ctrl+O (capital letter o) - this allows the next, and only the next command to be run in command mode, which is...
p Puts the yanked word, after this command is run you're still in insert mode
.inspect}" is the text that you type and finally...
^[ is Esc
I would go for:
nnoremap µ :s/^\s*\(\k\+\)\s*=.*/&\rputs "\1 = #{\1.inspect}"/<cr>
:s presents the advantage of doing the job plus matching the assigned variable if any. Doing the same thing with classical commands like yw, p, etc would be more cumbersome.
If the template become more complex, we can rely on template-file expanders as long as they easily permit to call viml function like matchstr(). Of course, in that case I would use mu-template with the following template-file:
VimL:" $Id: {rtp}/template/ruby/inspect.template
VimL: let s:value_start = '¡'
VimL: let s:value_end = '¡'
VimL: let s:reindent = 1
VimL: let s:marker_open = '<+'
VimL: let s:marker_close = '+>'
VimL: let s:varname = matchstr(getline(line('.')-1), '^\s*\zs\k\+\ze\s*=')
VimL: if empty(s:varname) |throw "the previous line don't assign any variable" |endif
puts "¡s:varname¡ = #{¡s:varname¡.inspect}"<++>
VimL:"vim: encoding=utf-8
If you're doing these on the fly, a snipmate snippet could look like this:
${1:error} = '${2:error message here}'
puts "error = #{$1.inspect}"
If, on the other hand you're just wanting to output pre-existing variables for debugging purposes. Nick-Canzoneri's macro may be more useful.
I want to use vim to write a part of my file to another file. For example, I have the following file:
This is line 1
and this is the next line
I want my output file to read:
line 1
and this is
I know how to use vi to write a range of lines to a file:
:20,22 w partial.txt
An alternative is to visually select the desired text and then write:
:'<'> w partial.txt
However, when using this method, vim insists on writing the full line in the output, and I have found no way to write a partial line. Any thoughts?
I've got two (very similar) approaches to this. There's no way to do it with the built in write command, but it's fairly easy to generate your own function that should do what you want (and you can call it what you like - even W if you want).
A very simple approach that will only handle single-line ranges is to have a function like this:
command! -nargs=1 -complete=file -range WriteLinePart <line1>,<line2>call WriteLinePart(<f-args>)
function! WriteLinePart(filename) range
" Get the start and end of the ranges
let RangeStart = getpos("'<")
let RangeEnd = getpos("'>")
" Result is [bufnum, lnum, col, off]
" Check both the start and end are on the same line
if RangeStart[1] == RangeEnd[1]
" Get the whole line
let WholeLine = getline(RangeStart[1])
" Extract the relevant part and put it in a list
let PartLine = [WholeLine[RangeStart[2]-1:RangeEnd[2]-1]]
" Write to the requested file
call writefile(PartLine, a:filename)
endif
endfunction
This is called with :'<,'>WriteLinePart test.txt.
If you want to support multiple line ranges, you could either expand this to include varying conditions, or you could pinch the code from my answer to this question. Get rid of the bit about substituting backslashes and you could then have a very simple function that does something like (untested though...) this:
command! -nargs=1 -complete=file -range WriteLinePart <line1>,<line2>call writelines([GetVisualRange()], a:filename)