Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
my personal vim repository
VimL Shell
branch: master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
.vim-fuf-data
autoload
bundle
colors
compiler
ftdetect
ftplugin
indent
plugin
snippets
syntax
.viminfo
README.md
vimrc

README.md

Vim configuration for cloud development

This configuration is a work-in-progress...

How to install?

You can check out the git repo and symlink .vimrc

git clone git://github.com/agaviria/.vim.git
ln -s ~/.vim/vimrc ~/.vimrc

Vim Plugins management (Vundle)

To install all plugins found in .vimrc you must do the following:

  • either within vim(Normal mode): :BundleInstall
  • or in your shell: vim +BundleInstall +qall

You don't have to do anything else: it just works.

Plugins

  • T-Comment- Allows easy comments in vim.
  • vim.surround - Plugin for deleting, editing, and adding surrounding (tags).
  • fugitive.vim - Git wrapper for vim.
  • repeat.vim - maps ( . ) to repeat the last command.
  • FuzzyFinder - quickly reach the buffer/file/command/bookmark/tag with fuzzy search pattern.
  • Nerdtree - allows you to explore your filesystem and open files or directories in hierarchical structure.
  • AutoClose - auto-complete for open-close pair of characters that have matching (closing) counterpart.
  • Syntastic - a syntax checking plugin that runs files through external syntax checkers and displays any resulting errors instantly.
  • snipMate - allows you to create custom snippets [go.snippets]

T-Comment

primary key maps for normal and insert mode: .

gc{motion} :: Toggle comments (for small comments within one line
                the &filetype_inline style will be used, if
                defined)
gc<Count>c{motion} :: Toggle comment text with count argument
                (see |tcomment#Comment()|)
gcc :: Toggle comment for the current line
gC{motion} :: Comment region
gCc :: Comment the current line

In visual mode:

gc :: Toggle comments
gC :: Comment selected text

A secondary set of key maps is defined for normal and insert 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>

vim.surround

Delete surroundings is ds . The next character given determines the target to delete. The exact nature of the target is explained in |surround-targets| but essentially it is the last character of a |text-object|. This mapping deletes the difference between the "i"nner object and "a"n object. This is easiest to understand with some examples:

Old text Command New text ~

"Hello *world!" ds" Hello world!
(123+4*56)/2 ds) 123+456/2
<div>Yo!*</div> dst Yo!

Change surroundings is cs . It takes two arguments, a target like with |ds|, and a replacement. Details about the second argument can be found below in |surround-replacements|. Once again, examples are in order.

Old text Command New text ~

"Hello *world!" cs"' 'Hello world!'
"Hello *world!" cs"<q> <q>Hello world!</q>
(123+4*56)/2 cs)] [123+456]/2
(123+4*56)/2 cs)[ [ 123+456 ]/2
<div>Yo!*</div> cst<p> <p>Yo!</p>

ys takes a valid Vim motion or text object as the first object, and wraps it using the second argument as with |cs|. (It's a stretch, but a good mnemonic for "ys" is "you surround".)

Old text Command New text ~

Hello w*orld! ysiw) Hello (world)!

As a special case, yss operates on the current line, ignoring leading whitespace.

Old text Command New text ~

Hello w*orld! yssB {Hello world!}

There is also yS and ySS which indent the surrounded text and place it on a line of its own.

vim.fugitive

Add %{fugitive#statusline()} to 'statusline' to get an indicator with the current branch in your statusline.

COMMANDS fugitive-commands

These commands are local to the buffers in which they work (generally, buffers that are part of Git repositories).

fugitive-:Git :Git [args] Run an arbitrary git command. Similar to :!git [args] but chdir to the repository tree first.

fugitive-:Git! :Git! [args] Like |:Git|, but capture the output into a temp file, and edit that temp file.

fugitive-:Gcd :Gcd [directory] |:cd| relative to the repository.

fugitive-:Glcd :Glcd [directory] |:lcd| relative to the repository.

fugitive-:Gstatus :Gstatus Bring up the output of git-status in the preview window. The following maps, which work on the cursor line file where sensible, are provided:

                    <C-N> next file
                    <C-P> previous file
                    <CR> |:Gedit|
                    - |:Git| add
                    - |:Git| reset (staged files)
                    cA |:Gcommit| --amend --reuse-message=HEAD
                    ca |:Gcommit| --amend
                    cc |:Gcommit|
                    cva |:Gcommit| --amend --verbose
                    cvc |:Gcommit| --verbose
                    D |:Gdiff|
                    ds |:Gsdiff|
                    dp |:Git!| diff (p for patch; use :Gw to apply)
                    dp |:Git| add --intent-to-add (untracked files)
                    dv |:Gvdiff|
                    O |:Gtabedit|
                    o |:Gsplit|
                    p |:Git| add --patch
                    p |:Git| reset --patch (staged files)
                    q close status
                    R reload status
                    S |:Gvsplit|

fugitive-:Gcommit :Gcommit [args] A wrapper around git-commit. If there is nothing to commit, |:Gstatus| is called instead. Unless the arguments given would skip the invocation of an editor (e.g., -m), a split window will be used to obtain a commit message. Write and close that window (:wq or |:Gwrite|) to finish the commit. Unlike when running the actual git-commit command, it is possible (but unadvisable) to muck with the index with commands like git-add and git-reset while a commit message is pending.

fugitive-:Ggrep :Ggrep [args] |:grep| with git-grep as 'grepprg'.

fugitive-:Glgrep :Glgrep [args] |:lgrep| with git-grep as 'grepprg'.

fugitive-:Glog :Glog [args] Load all previous revisions of the current file into the quickfix list. Additional git-log arguments can be given (for example, --reverse). If "--" appears as an argument, no file specific filtering is done, and previous commits rather than previous file revisions are loaded.

fugitive-:Gllog :Gllog [args] Like |:Glog|, but use the location list instead of the quickfix list.

fugitive-:Gedit fugitive-:Ge :Gedit [revision] |:edit| a |fugitive-revision|.

fugitive-:Gsplit :Gsplit [revision] |:split| a |fugitive-revision|.

fugitive-:Gvsplit :Gvsplit [revision] |:vsplit| a |fugitive-revision|.

fugitive-:Gtabedit :Gtabedit [revision] |:tabedit| a |fugitive-revision|.

fugitive-:Gpedit :Gpedit [revision] |:pedit| a |fugitive-revision|.

:Gsplit! [args] fugitive-:Gsplit! fugitive-:Gvsplit! :Gvsplit! [args] fugitive-:Gtabedit! fugitive-:Gpedit! :Gtabedit! [args] Like |:Git!|, but open the resulting temp file in a :Gpedit! [args] split, tab, or preview window.

fugitive-:Gread :Gread [revision] Empty the buffer and |:read| a |fugitive-revision|. When the argument is omitted, this is similar to git-checkout on a work tree file or git-add on a stage file, but without writing anything to disk.

:{range}Gread [revision] |:read| in a |fugitive-revision| after {range}.

fugitive-:Gread! :Gread! [args] Empty the buffer and |:read| the output of a Git command. For example, :Gread! show HEAD:%.

:{range}Gread! [args] |:read| the output of a Git command after {range}.

fugitive-:Gw fugitive-:Gwrite :Gwrite Write to the current file's path and stage the results. When run in a work tree file, it is effectively git add. Elsewhere, it is effectively git-checkout. A great deal of effort is expended to behave sensibly when the work tree or index version of the file is open in another buffer.

:Gwrite {path} You can give |:Gwrite| an explicit path of where in the work tree to write. You can also give a path like :0:foo.txt or even :0 to write to just that stage in the index.

fugitive-:Gwq :Gwq [path] Like |:Gwrite| followed by |:quit| if the write succeeded.

:Gwq! [path] Like |:Gwrite|! followed by |:quit|! if the write succeeded.

fugitive-:Gdiff :Gdiff [revision] Perform a |vimdiff| against the current file in the given revision. With no argument, the version in the index is used (which means a three-way diff during a merge conflict, making it a git-mergetool alternative). The newer of the two files is placed to the right. Use |do| and |dp| and write to the index file to simulate "git add --patch".

fugitive-:Gsdiff :Gsdiff [revision] Like |:Gdiff|, but split horizontally.

fugitive-:Gvdiff :Gvdiff [revision] Identical to |:Gdiff|. For symmetry with |:Gsdiff|.

fugitive-:Gmove :Gmove {destination} Wrapper around git-mv that renames the buffer afterward. The destination is relative to the current directory except when started with a /, in which case it is relative to the work tree. Add a ! to pass -f.

fugitive-:Gremove :Gremove Wrapper around git-rm that deletes the buffer afterward. When invoked in an index file, --cached is passed. Add a ! to pass -f and forcefully discard the buffer.

fugitive-:Gblame :Gblame [flags] Run git-blame on the file and open the results in a scroll bound vertical split. Press enter on a line to reblame the file as it was in that commit. You can give any of ltfnsewMC as flags and they will be passed along to git-blame. The following maps, which work on the cursor line commit where sensible, are provided:

                    A resize to end of author column
                    C resize to end of commit column
                    D resize to end of date/time column
                    q close blame and return to blamed window
                    gq q, then |:Gedit| to return to work tree version
                    <CR> q, then open commit
                    o open commit in horizontal split
                    O open commit in new tab
                    - reblame at commit
                    ~ reblame at [count]th first grandparent
                    P reblame at [count]th parent (like HEAD^[count])

:[range]Gblame [flags] Run git-blame on the given range.

fugitive-:Gbrowse :[range]Gbrowse If the remote for the current branch is on GitHub, open the current file, blob, tree, commit, or tag (with git-web--browse) on GitHub. Otherwise, open the current file, blob, tree, commit, or tag in git-instaweb (if you have issues, verify you can run "git instaweb" from a terminal). If a range is given, it is appropriately appended to the URL as an anchor. To use with GitHub FI, point g:fugitive_github_domains at a list of domains:

let g:fugitive_github_domains = ['https://example.com']

:[range]Gbrowse! Like :Gbrowse, but put the URL on the clipboard rather than opening it.

:[range]Gbrowse {revision} Like :Gbrowse, but for a given |fugitive-revision|. A useful value here is -, which ties the URL to the latest commit rather than a volatile branch.

:[range]Gbrowse [...]@{remote} Force using the given remote rather than the remote for the current branch. The remote is used to determine which GitHub repository to link to.

Something went wrong with that request. Please try again.