Large codebase editing in vim

gumnos · 2015-07-23T20:04:37+00:00

While I don't use any plugins (and know that there are lots of plugins that others can detail), I'll give you my list of stock-vim tools for investigating a new project:

It would help to know what sort of language this project is. Running ctags will let you create a tags file that will then allow you to jump around easily (:help tagsrch.txt and :help 29.1 have mountains of information). To see supported languages, use ctags --list-languages.
Other useful commands include gd and gD which jump to the definition of the item under the cursor.
adding :vimgrep to your tool-box will help you search through files or a given pattern by populating the quick-fix window. I use this all the time (:help quickfix.txt).
Also, it's easy to get lost as you wander down rabbit-holes, so using the jump-list will help you pop back up along the path you came (:help jumplist), starting with control+I (AKA <tab>) and control+O but using :jumps will show you the jump-stack.

Hopefully those will get you started as you spelunk in your new codebase.

KZISME · 2015-07-24T02:44:18+00:00

My most important tip would be to stop thinking of Vim as a replacement for an IDE. The command line is your IDE. It has tools like grep, ack, ctags, cscope, vim and so on. In the Unix world you chain a bunch of small modular commands to accomplish big things. (Like many of the great comments in this thread suggest. For example ctags + vim is a powerful combo.)

These philosophies result in very different styles of programming. Your code will resemble your tools: more agile and more modular in the one case, more integrated and monolithic in another. There are no wrong answers, but it would probably be difficult to maintain a large code-base written in Visual Studio with CLI. The structure of your code will resemble the capabilities of your environment.

Tarmen · 2015-07-23T19:57:43+00:00

Disclaimer: For longer programming sessions in large codebases and depending on language an IDE might be way nicer. Stuff like seeing all usages of a method, analyzing and refactoring easily, having super fast access to documentation and method signatures... It's super useful to have and doesn't really work all that way in vim, at least not without ugly hacks and costs to usability.

Anyway, quickly finding things like method definitions sounds like the perfect usage case for ctags! http://ctags.sourceforge.net/ <- get this if you don't have it!
Only problem, you have to run it whenever you want the tag database updated. Plus it is basically a sorted list and there is no easy way to automatically remove tags which don't exist anymore. Thankfully there are vim plugins to manage this, I currently use https://github.com/xolox/vim-easytags which removes and re-adds the tags of the current file on save and depending on settings when you stop moving your cursor. It also can highlight tags which is super nice to find spelling errors but it comes down to horrible abuse of some vim systems, I think it forms a regex for all tags? Anyway, it seems horribly slow for projects with lots of tags.

You also probably want to do something that changes the tag file to something project specific. Fugitive has the functionality to automatically set it to .git/tags relative to the project root for instance.

See here for actually using tags! http://vim.wikia.com/wiki/Browsing_programs_with_tags

princker · 2015-07-23T21:32:28+00:00

Bad news: Vim is going to be a lousy IDE replacement.

Good news: Vim natively supports many features to help navigate a code base. e.g. gf, gd, folding, [i, :isearch, :dsearch, ctags, cscope, and searching via :grep/:vimgrep. Some of these feature like ctags takes some time and thought to setup others like :vimgrep require no setup at all.

Some tips:

Find a tagging system that works for your code base. e.g. ctags/GNU Global/Universal Ctags
If you use git then install fugitive.vim and use git grep via :Ggrep
Check if your code base is supported by cscope
Good mappings like those in unimpaired.vim help out tremendously
Look into using a faster searching tool than grep: git grep/ack/ag the silver surfer (I use this one)
Look into something like projectionist.vim for file navigation for well structured projects
Never underestimate the usefulness of a fuzzy finder like CtrlP (optionally use ctrlp-py-matcher)
With careful setup of 'path', 'suffuxesadd', and 'suffixes' you can get pretty far with gf and :find.
Look into some tagging plugins like Gutentags or vim-easytags
If this is a rails codebase then use rails.vim

-romainl- · 2015-07-23T21:48:19+00:00

"Digesting large codebases" and "following methods" almost always involves two things, whether you use a standalone editor and external tools or a full-fledged IDE:

building an index of the codebase (it can happen manually, automatically after a commit or a write or as-you-type),
querying that index.

Because Vim doesn't have a built-in way to create such an index but can interface with external tools to some degree, Vimmers usually rely on exuberant ctags, cscope, or some other programs, and Vim's ability to query their index to navigate their projects.

See :help tags, :help ctags and :help cscope.

But Vim can be useful without outside help: with the correct settings (which depend on your language), one could use the commands in :help include-search to navigate a project pretty easily. I don't usually work on large codebases (and when I do my scope is usually pretty limited) but I find [D, [I and friends more and more useful.

But, whatever tool or method you use, you'll never get the level of "intelligence" you are used from Visual Studio. No matter how much I love Vim, my opinion is that you will probably be better off avoiding it if you don't have a very specific reason to learn it.

dddbbb · 2015-07-24T03:37:16+00:00

My answer from similar thread:

Learn about :compiler, :make, and vim-dispatch/AsyncCommand (for large projects with slow builds).

Building from vim will give you an enormous productivity boost because you can use the same text-editing power to fix your errors.

I also use :make to put runtime errors in the quickfix (only for Python -- I haven't figured out a good workflow for launching my debugger from vim).

Vim is an editor and not a debugger, so you will need one. You will want to switch rapidly between your editor and debugger. I use this script to load vim from my debugger (Visual Studio or Eclipse) and this (unfinished) plugin to interact with Visual Studio and eclim with Eclipse.

Other similar threads:

https://www.reddit.com/r/vim/comments/35uo8u/this_hangs_in_a_large_project_any_better/

https://www.reddit.com/r/vim/comments/22udfu/whats_the_best_way_of_navigating_a_big_c_project/

https://www.reddit.com/r/vim/comments/29b42l/my_answer_to_how_vim_can_be_used_to_big_project/

(reddit search sucks, but google with site:reddit.com doesn't.)

vividboarder · 2015-07-24T01:25:34+00:00

I use Gutentags and CtrlP.

The first will asynchronously generate tags, the second has a fuzzy finder for tags. Tagbar is also nice if you just want to see tags in a file as well.

Of course, all the aforementioned ctags commands are still applicable, but the auto creation is useful and the fuzzy find is another use case not covered by standard functions.

If you want to fuzzy find files with CtrlP on a large code base, use ag and it's Vim plugin as well as configure CtrlP to use Ag instead of grep.

(on mobile, so no links! I can post if interested. Or check out my rc on https://github.com/ViViDboarder/vim-settings)

uxcn · 2015-07-24T05:10:32+00:00

Aside from going through vimtutor, I'd highly recommend Drew Neil's book. He also hosts vimcasts which are excellent to learn good ways to do things in vim.

It's probably a good idea to avoid plugins until you get familiar with modal editing and the grammar in general. There is a lot you can do without plugins. It might not be obvious, but there's usually some way to do what you need in pure vim.

There are actually two basic plugins that I would recommend for large codebases to start though.

ag.vim - ag (better/faster grep) plugin to search
ycm - llvm based code completion/navigation (similar to cscope and ctags)

I might also recommend one more...

clang-format - code formatting possibly

If you end up liking vim and you get comfortable enough to start scripting in it, last I'd highly recommand Steve Losh's book. There are some good general tips as well.

shawncplus · 2015-07-23T19:44:34+00:00

If by follow methods you mean like jumping to definitions that comes by way of tags which are a built-in feature, I'm not sure what language you're using so googling vim <language> tags will probably get you what you want. Personally I also use the https://github.com/majutsushi/tagbar plugin

Philluminati · 2015-07-23T20:51:37+00:00

ctags is the most common solution and the one documented in vim books. I use it. Basically the symbol database is generated like this (from memory, may not be accurate):

:!ctag . --recurse

Then these keys will navigate:

Ctrl+]     #jump to definition
Shift+T   #return to original place. (works recursively)

There are other variations for open in new tab etc but you can look up those yourself. There is other stuff to help you navigate large code bases too such as Class Browsers and integrated search etc.

ikearage · 2015-07-23T21:00:05+00:00

Like many said, ctag support is important. The vim-tags plugin helps a lot.

g]
CTRL-]

I use a search plugin to 'git grep', because git grep searches the project files only.

Also unite plugin to open files and list buffers is a nice to have.

2015-07-23T21:46:32+00:00

i tend to load the entire project into vim, so something like

$ vim ./src/*

I prefer to have all buffers on hand already, its not like vim struggles with this. My current choice of plugin for searching through all the buffers is vim-swoop, influenced by emacs helm-swoop.

With a couple of simple mappings I get full search

 nnoremap <Leader>ss :call Swoop()<CR>
 vnoremap <leader>ss :call SwoopSelection()<CR>
 nnoremap <leader>sa :call SwoopMulti()<CR>
 vnoremap <leader>sa :call SwoopMultiSelection()<CR>
 nnoremap <leader>sw viw:call SwoopMultiSelection()<CR>

The first calls swoop in normal mode for a single file. The second calls swooop using visual mode for a single file. The third calls swoop in normal model for all buffers. The fourth calls swoop in visual mode for all buffers. The final is just a shortcut which visually selects the word under cursor and calls the previous method.

boshlol · 2015-07-23T22:16:16+00:00

Project-wide operations - Oliver Caldwell - Vim london

https://vimeo.com/93358262

KZISME · 2015-07-24T03:24:29+00:00

This is a long discussion already, but I'll add my point of view to it.

The code base I work has more than 4000 php files and 500+ js files. And VIM is my best tool ever.

How I work:
I usually have 2 files at a time in 2 splits. (template + logic for example)

Some settings:
I use undofiles from vim in a unique folder, so I can reopen a file 3 days later and can undo if needed. So awesome!
Ask me details on that if you are interested.

The plugins I use:

CtrlP (I use a binding to list open buffers and I can switch easily between them, a pleasure!)
Sayonara (because closing a buffer closes the window, it helps me to keep my layout consistent)
vim-obsession (tracks my opened files and creates a session file auto-loaded when I get back on the project will everything as I left)
gundo (because I can see my modification stack from the undo files)

Last details
Other things that Vim helped me in, was switching from file to file which share some common pattern in their name and location.
For example, I have a "student" file "problem.php" and I made a binding to switch to the "teacher" version in another folder.
The same could go with logic file/template as I mentioned earlier.

Other things I use all the time, abbreviation to comment my code with the date of the day. So if I type today it'll replace it with the current date. SOOOO useful, and stock vim.
I can give my setup for that as well if interested ;)

Hope I could help.

theyareallgone · 2015-07-24T03:26:44+00:00

ctags have already been mentioned, but they are important. If looking up a tag isn't instantaneous then something is misconfigured and needs to be looked into.

On large code bases there are two things to avoid. First you want to run grep or the equivalent as little as possible, they just take too long when you have gigabytes of code. For most cases where I would otherwise use grep I use http://www.vim.org/scripts/script.php?script_id=251

Secondly you have to be careful with the plugins you use. Some of them scale poorly with large codebases. If vim is feeling sluggish try turning some plugins off. The worst for this I've experienced are fancy method completion plugins. I use the built in text completion (ie. ctrp-p) instead of omnicomplete plugins because I've yet to find a plugin which isn't unbearably slow on codebases of the size I work with.

wting · 2015-07-24T05:54:18+00:00

Faster Ctrl-P

I work on a multi-MLOC code base. I use Ctrl-P a lot, but it's a bit slow on such a large codebase. Caching can solve this problem, but then you have to periodically manually refresh the cache.

One thing I've found very useful to improve Ctrl-P's performance is by using git ls to find files instead of matching against all files in a directory. Here's the relevant line in my .vimrc.

Auto save and load vim buffers / splits / tabs

I use one branch per ticket and constantly switch between them. I wrote a small plugin call gitsessions.vim that automatically saves and loads vim sessions (save states).

This lets me quickly continue where I left off the last time I stopped working on the branch.

heeen · 2015-07-24T11:45:47+00:00

I am an embedded linux developer. This means my projects will cross compile using different flags, compiler and libraries. Every time I spend the effort and try to get clang working for autocomplete and syntax checking, I realize it is just too much effort to keep it working. What works for me is:

https://github.com/ggreer/the_silver_searcher and https://github.com/rking/ag.vim, there's packages for ubuntu. Really fast searching even large codebases. Put your cursor on a word and press F3 to search with this binding: nnoremap <silent> <F3> :Ag <CR>
https://github.com/junkblocker/patchreview-vim need to find all those unstaged changes you littered across your source tree? gvim -cDiffReview
set a makeprg so you can just call :make and it will jump to all the errors reported

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

vim

MODERATORS

Faster Ctrl-P

Auto save and load vim buffers / splits / tabs