I'm currently trying to write a script allowing to call a Vim command, which in turns calls an external command. I want to enable auto-completion with results within a list of files having a specific extension (see code below).
The completion actually circles through the list of files with the given extension, but when I start typing something and press tab, the completion is cycle is repeated from the start of the list, regardless of what's being entered (instead of actually completing the rest of the file name given in input). The code is the following:
call CreateEditCommand('EComponent', 'ComponentFiles')
function! CreateEditCommand(command, listFunction)
silent execute 'command! -nargs=1 -complete=customlist,'. a:listFunction . ' ' . a:command . ' call EditFile(<f-args>)'
endfunction
function! ComponentFiles(A,L,P)
return Files('component.ts')
endfunction
function! Files(extension)
let paths = split(globpath('.', '**/*.' . a:extension), "\n")
let idx = range(0, len(paths)-1)
let g:global_paths = {}
for i in idx
let g:global_paths[fnamemodify(paths[i], ':t:r')] = paths[i]
endfor
call map(paths, 'fnamemodify(v:val, ":t:r")')
return paths
endfunction
function! EditFile(file)
execute 'edit' g:global_paths[a:file]
endfunction
For instance, if I have: app.component.ts, and test.component.ts and I type
:EComponent test
and press tab, the completed command will is the following
:EComponent app.component.ts
instead of:
:EComponent test.component.ts
Thanks in advance for your help on this.
ComponentFiles() is supposed to filter the list of files based on the characters before the cursor (ArgLead) but you always return the same list so that function does nothing useful.
The custom completion function below returns only the items in ls that match the characters before the cursor:
function! MyComp(ArgLead, CmdLine, CursorPos)
return filter(systemlist("ls"), 'v:val =~ a:ArgLead')
endfunction
function! MyFunc(arg)
execute "edit " . a:arg
endfunction
command! -nargs=1 -complete=customlist,MyComp MyEdit call MyFunc(<f-args>)
See :help :command-completion-customlist.
Related
Inside a vim function I would like to have the user select a directory (instead of writing its name), I guess using :Explore, then get the filename of that directory and pass it to another function for example.
E.g. something like this
function! Test()
let directory = ????
call Test2(directory)
endfunction
This can be achieved with the browsedir() function:
function! Test()
let initialDir = '/home/'
let directory = browsedir('my prompt title', initialDir)
echo "directory = ".directory
endfunction
I want to dynamically change the way latex-suite determines the MainFile.
The main file is usually the latex header file which includes other tex files (like chapters and so on). Using the MainFile it is possible to hit compile on some chapter-file so that latex-suite automatically compiles the header file instead.
This should be possible with g:Tex_MainFileExpression:
http://vim-latex.sourceforge.net/documentation/latex-suite/latex-master-file.html
However, the expression is not documented at all and even the example (which imo should reflect the default behavior) does not work.
let g:Tex_MainFileExpression = 'MainFile(modifier)'
function! MainFile(fmod)
if glob('*.latexmain') != ''
return fnamemodify(glob('*.latexmain'), a:fmod)
else
return ''
endif
endif
Can somebody please shortly point out to me how this is supposed to be used?
What return expression is expected? Why does the example not work?
Background: I have a latexmain file in the project root. I also have a figure subdirectory. For this subdirectory the root latex main should not be ignored, so that the current file itself is compiled.
I just ran into the problem of not knowing how to set g:Tex_MainFileExpression as well. The documentation and the example were not clear to me either. Turns out, the source code defines a function Tex_GetMainFileName, which sets the variable modifier from its arguments before executing g:Tex_MainFileExpression (see source code here). Therefore, g:Tex_MainFileExpression needs to be a function that has the argument modifier (not called differently!). The vim-latex documentation says, that modifier is a filetype-modifier, therefore your function needs to return fnamemodify(filename, modifier). So it has to look like this:
let g:Tex_MainFileExpression = 'MainFile(modifier)'
function! MainFile(fmod)
" Determine the full path to your main latex file that you want to compile.
" Store it e.g. in the variable `path`:
" let path = some/path/to/main.tex
" Apply `modifier` to your `path` variable
return fnamemodify(path, a:fmod)
endif
Example
I used this in a project where I have a two main latex files, one for the main document and one for supplementary material. The project structure looks like this:
project/
main.tex
sup.tex
.local-vimrc
main-source/
input1.tex
input2.tex
sup-source/
input1.tex
input2.tex
I load a .local-vimrc file (using the plugin MarcWeber/vim-addon-local-vimrc), where I set g:Tex_MainFileExpression such that <leader>ll compiles main.tex if the file in the current buffer is located in the folder main-source and compiles sup.tex if it is in the folder sup-source. Below is my .local-vimrc file. I have very little experience with vimscript, so this is probably a littly hacky, but it might help to get an idea on how to use g:Tex_MainFileExpression. Also, I have modified it to be less messy and not tested the following code explicitly.
let g:Tex_MainFileExpression = 'g:My_MainTexFile(modifier)'
function! g:My_MainTexFile(fmod)
" Get absolute (link resolved) paths to this script and the open buffer
let l:path_to_script = fnamemodify(resolve(expand('<sfile>:p')), ':h')
let l:path_to_buffer = fnamemodify(resolve(expand('%:p')), ':h')
" Check if the buffer file is a subdirectory of `main-source` or `sup-source`
" stridx(a, b) returns -1 only if b is not substring of a
if stridx(l:path_to_buffer, 'main-source') != -1
let l:name = 'main.tex'
elseif stridx(l:path_to_buffer, 'sup-source') != -1
let l:name = 'sup.tex'
else
echom "Don't know what's the root tex file. '".#%."' is not in 'main-source/' or 'sup-source/' directory."
return ''
endif
" Concatenate this script path with main latex file name
" NOTE: this assumes that this script is located in the same folder as the
" main latex files 'main.tex' and 'sup.tex'
let l:path = l:path_to_script.'/'.l:name
return fnamemodify(l:abs_path_main, a:fmod)
endfunction
I'm trying to write a function in my vimrc that would allow me to "hover" the in vim cursor (not the mouse cursor) over the word in question and and create a doc comment (with the word already in the comment) along with the new subroutine. So I would start with just:
newSubName
and then hover over and call the sub, it would replace that with:
#------------------------------------------------------------------------------
# Subroutine: newSubName
# Function :
# Parms :
# Returns :
# Assumes :
#------------------------------------------------------------------------------
sub newSubName() {
}
I have the code for creating the sub "declaration" at the bottom of the file (got from internet), but I can't really decipher how to turn it into what I want. The code that I am using is:
function! Newsub()
let word = "sub " . expand("<cword>") . "()" . " {" . "}"
let ln = search("__.*__", 'nW')
if ln == 0
call append('$', word)
else
call append(ln-1, word)
endif
endfunction
Any and all help is appreciated.
Thanks,
RzITex
Any templates/snippets expander should simplify your life. For instance, with mu-template v2.4.0 (only available through svn/vim-addon-manager for the moment):
VimL: " {rtp}/after/template/{filetype}/func.template
#------------------------------------------------------------------------------
# Subroutine: <+g:func+>
# Function : <++>
# Parms : <++>
# Returns : <++>
# Assumes : <++>
# Date : <+strftime('%c')+>
# Author : <+g:myname_that_I_need_to_define_in_my_vimrc+>
#------------------------------------------------------------------------------
sub <+g:func+>() {
<++>
}<++>
and the ftplugin {rtp}/ftplugin/{filetype}.vim
" here the anti-inclusion guards, ...
" and the untested mapping
nnoremap <buffer> <c-x>f :let g:func=expand('<cword>')<cr>"_diw:exe "Mutemplate ".&ft."/func"<cr>:unlet g:func<cr>
Note: this mapping contain everything that you need:
obtain the current word (there are many other methods)
delete that word with "_diw (:h "_, :h diw)
apply something that will do the expansion. If you prefer to work manually with a function that calls :put, name it s:FuncExpand(name) for instance, and call it from the mapping with diw:call <sid>FuncExpand(#")<cr> (here I use another way to cut the function name under the cursor).
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)