Check out this articale on lifehacker.

Of particular interest is the jumping between arguments hotkeys. Currently, looks like they are bound to Esc-B & Esc-F. Yuck. remap to Ctrl-B & Ctrl-F and then set Ctrl-Shift-B & Ctrl-Shift-F to the single letter motions currently on those mappings.

MagicTags is serving well for updating tags while editing in Vim. Need to
investigage how to keep in sync when I change things outside of Vim.

Vim Tags plugin magic:

• Async full ctags run (using atomic ctags > tags.temp && mv tags.temp tags)
• Hooked into bufenter

Keep them in ./.git

Consider Universal Ctags maintained fork. Per drew neil on twitter

Use gem-ctags from tpope for gem tags
Use bundler.vim to get vim to recognize the ctags in gems
Fugivitive.vim will already check for

• Fire off a full Ctags regen when starting Vim async & silent
• Using a git hook
• Good overview on vim ctags interaction
• Excellent ctags config file with ruby, js, and coffeescript support

Ruby

Ripper tags better support for constants
Issue summary on vim-ruby repo wiki
Excellent .ctags file with ruby extensions

Coffeescript

• Ctags commands for coffeescript
• Alternate coffeescript ctags generation code
• Gem for coffeescript tag generation
• Another set of coffeescript ctags rules

Vimscript

• Better vimscript ctags scoping
• Script local funcation awareness

Consider integrating Gem Ctags

Also consider integrating EasyTags features, including syntax highlighting for tags

This guy wrote a detailed blog post on fancy tag manipulation as well as an
earlier blog post on interacting with the taglist.

Another blog post about Ctags vim browsing

Prose

Quick Links

Want an in context way to run a Google search and create a Markdown link for the top result. Thinking that shelling out to a simple script, ala Brett Terpstra's script here could make sense. Alternately, the GIFL plugin uses inline ruby within the plugin to do the fetching. Likewise, this could be accomplished with webapi-vim

Switching Case

Would like map for switching case of words. Particularly useful to title case some words, but could be more generally useful. Vimtips has a related tip

Local Dictionary

Also need to figure out how to setup local dictionary (for adding new words) and thesaurus

From tpope's vimfiles

if exists("+spelllang")
  set spelllang=en_us
endif
set spellfile=~/.vim/spell/en.utf-8.add
setlocal spell spelllang=en_us
set spellfile=~/.vim/spellfile.add
set thesaurus+=/Users/sbrown/.vim/thesaurus/mthesaur.txt

Fan off formatoption+=a, but only while typing. Could I selectively enable it?

autocmd InsertEnter markdown call EnableWrapIfInParagraph()
autocmd InsertLeave markdown setlocal formatoptions-=a

function! EnableWrapIfInParagraph()
    " code that looks at current line and preceding / following line to
    " determine if currently in a 'paragraph'
    setlocal formatoptions+=a " Enable automatic line wrapping
function

Undo points during prose writing

https://github.com/nother/vim-prose/blob/master/plugin/vimprose.vim

" set an undo point at the ends of sentences since it's common
" to write a fair amount before leaving insert mode.
inoremap <buffer> . .<C-g>u
inoremap <buffer> ! !<C-g>u
inoremap <buffer> ? ?<C-g>u
inoremap <buffer> : :<C-g>u

vim-pencil seems to ship with this, plus some other fun.

Another option would be to define a custom formatexpr, or to use the fo+=t
option which only updates while in insert mode.

Moving between wiki pages and tags

I want to be able to hit <tab> and <S-tab> to jump bewteen the previous and next link or tag in the document. I then want to be able to hit <cr> and either open the URL, or follow the wiki link. Currently having an issue with links that break across lines, ie>

this is a line with a [link that
spans lines](http://google.com)

Proofing

Incorporate checks for passive voice, weasel words, etc. Ref this words to avoid script, as well as this list of plugins for prose. Perhaps it could be expanded to highlight various aspects of a piece of writing like hemingwayapp using a technique similar to easytags dynamic highlighting
Similar features were recently add to Draft. Consider using something like Vim marks to highlight words used multiple times.

Vim wordy is a plugin for hemingway like functionality in vim

Bundle directives can be sourced in by using this runtime include technique

Using AutoComplPop and so far liking it. New goal:

• autoComplPop does its magic to open completion menu
• <C-j>``<C-k> for up / down
• Tab to accept current menu item
• Tab without menu does snippet expansion
• acts as normal carriage return (including vim-endwise behavior)

Additionally, I would like to selectively enable disable AutoComplPop based on the current buffer:

• Markdown, text, unknown => disable,
• code => enable

I regularly will type something that is a substring of a longer match and autocomplpop basically wont let me finish the line with that substring. Enter should cut this off

Conversly, I almost never insert tab literals

https://github.com/ecomba/vim-ruby-refactoring

Specifically interested in extract-method

• Fetch remote and compare to see if update is FF-able. If not, warn (force with -f option)
• Determine the new commits that are going up and if they contain a migration
• Reference Mislav's git-deploy for a command to check for migrations git diff #{oldrev} #{newrev} --diff-filter=A --name-only -z db/migrate
• If so, warn the user that they need to run a migration

Scroollosse's Syntastic plugin for syntax checking goodness

Figure out the most use git commands with args:

history | ack '^\s+\d+\s+g\s\w+\s\w'

Figure out the most used subcommands (checkout, stash, show, etc) and provide solid completion for them

Criteria for solid:

• Consistent runtime (don't hang)
• Smart (last 100 commit shas for show, local branches for checkout, remote branches for checkout -t, etc)
• FAST

Overarching vision => super easy management of bundles on both systems

• BUNDLE: directives can be stored in alt file to $MYVIMRC (allow splitting of vimrc into rcfiles/*)
• Install command / script outputs summary with tag, sha, etc identifier for specific version
• Cross platform (cause sometimes you gotta Windows)

Updates:

• Add notes about brew install macvim and gvim install + Vundle recommendations
• Kill the colors dir, use bundle instead
• Add bundles/README.md
• Update colroscheme def in ctwombat to name as "ctwombat"
• Set g:my_vimrc in if for both windows and unixy ($HOME/.vimrc or $VIM/_vimrc)
• Add rs for sourcing g:my_vimrc file

REM Note: this all must be run as Administrator (specifically the mklink)
cd /d %USERPROFILE%
mklink /d .vim .\code\dotfiles\vim
mkdir code\dotfiles\vim\bundles
git clone https://github.com/gmarik/vundle.git .vim\bundles\vundle
mklink _vimrc .\code\dotfiles\vim\vimrc
cd /d "\Program Files\Vim"
mklink /h _vimrc %USERPROFILE%\code\dotfiles\vim\windows_vimrc
REM Now open gVim and run :BundleInstall<cr>

Antigen allows for configuration via inclusion of plugin files very much like Vundle.

Also reference prezto for additional modular zsh configurations

Also look into grml

Similar is zgen

Also check out dotzsh for community managed plugins and completion.

Also zplug seems nifty

and awesome zsh plugins seems worth a peek

• Custom scripts should be tab complete able
• Path completion is super slow. Why?
• How to include help for custom sub-commands / scripts?

Use the Giant Robots post as a starting point, but don't clear the tmux paste buffer list

• User a generic plist file so others can take advantage (and it can live in dotfiles)
• Poll every few seconds and store the last found text. Only push to pbcopy if changed

• Accept target branch for merging into
  • default to master with git cpr, but accept git cpr dev to merge into dev or other branch
• Check that the merge is fast-forwardable before checking out:
  • git merge-base --is-ancestor master origin/to-test-setup

Current issues / desired features:

• Want 256 colors vim / tmux display with nice colorscheme for vim
• Access to system clipboard from within vim
• tmux does not accept input (frozen) when I come back to a session after a while. It still recognizes tmux cmds, ie Prefix d to detach, but won't pass anything to the underlying programs (vim, zsh, etc).
• meta key in OS X tmux?
• "Maximize" sequence as toggle (rather than + to max, - to minimize)

Nice to haves:

• Figure out how to do tsliming with ruby functions or similar (escape newlines? join with semicolons?)

Might want to incorporate this fix to allow copy paste

Complete:

• Vim slow to startup in tmux. First file very slow to open ( > 5s) Looks like this was caused by skammer/vim-css-color
• Tslime.vim to push from vim to other pane. (Send enter by using double quotes and appending "\n". How can I send Ctrl-l to clear?)
  (Use to insert "^l" for screen clear, "\n" for enter)
• quick session switching (list-sessions provides a nice navigable list. How to open on enter?) (use Prefix C-l)

Really like how vimux simplifies the opening of a tmux pane for command running.

Need to integrate the test runners listed in the README. Want easy access to run current test file, run focused test, etc

Need to hook into the pane open command so that it moves to the root. This can be opted out of, but it seems that is the issue for the test runners as of now.

Would be nice to be able to use the tmux break-pane functionality to dismiss test / runner pane, rather than fully closing it.

http://victorquinn.com/blog/2011/12/22/solved-zsh-git-tab-completion-painfully-slow/
https://github.com/bobthecow/git-flow-completion/wiki/Update-Zsh-git-completion-module

Blocking issues:

• The rails maps I have for Command-T under various directories only work the first time. After I have a file selected, it will only display the matches in the current file's directory

torkale/dotvim@6a31833 to tor-ivry/dotvim added them, but a later commit removed them

Nice to have:

• Sort alphabetically (why sort by filename length?)

Meet bundler.vim. Worth it just for the internalized bundle open. http://t.co/fy1mB7H

The plugin should find each span of lines that do not match a regex (g:reformatter_matchers += /asdf/ ?) and then gq them to reformat.

Want this for blog posts. Ignore yaml frontmatter, skip code blocks and block quotes?

https://github.com/garybernhardt/dotfiles/blob/master/bin/rename-identifier

This handles opening Vim with relevant file list for given identifier and mappings for changing.

What about filenames and variants on identifier name, ie Project => projects

Currently the mapping of ; to : sea to break space.vim with regard to g; (go to last edit position) jumping. This needs fixed

git debranch <commit-sha> <new-branch-name>

Provide zsh list style tab completion (ala chmod <tab>) including
a5d67fe - Revert this thing
3489ba - Make that change

Fail if uncommitted changes or in working directory or index

This looks like a good article on custom zsh tab completion scripts

seems like a prime candidate for the leader. Accesible and keeps both hands essentially free to tap out the rest of the mapping.

Would need to create a Space.vim variant that works with another key. thinking tab could work well as the replacement for space. Added bonus that the reverse mapping, Shift-Tab, should work in the termianl. Currenlty Space-tab does not.

http://vim.wikia.com/wiki/Make_Shift-Tab_work

Use this to take current command and edit in vim. Useful for iterative building of multi setp piped commands.

# Stolen from Gary Bernhardt
# Use C-x C-e to edit the current command line
autoload -U edit-command-line
zle -N edit-command-line
bindkey '\C-x\C-e' edit-command-line

Seems the brew version of vim on mountain lion has broken clipboard something.

http://vim.wikia.com/wiki/In_line_copy_and_paste_to_system_clipboard
This link has vim wrappers around system calls to pbcopy and pbpaste. Not perfect, but ok work around for now.

Base it off this gist. Remap caps to control

Been a fun experiment, but I think its time to go back. Would like to still have Command-T esque fuzzy matching with this.

• Ref issue #26 re: combination indent and marker folding.
• Create a custom fold expression to look up the file for the previous marker, then add the indent level based on sw
• Create a rf map that uses CtrlP generic to jump to and open specific section. Same with rp for plugin
• Create a function and associated visual map <C-s>? to source a visually selected region of vimrc

function! VisualSource()
    let lines = GetVisualSelection()
    let lines_list = split(lines, "^@")
    for line in lines_list
        execute line
    endfor
    normal! gv
endfunction

function! GetVisualSelection()
    try
        let a_save = @a
        normal! gv"ay
        return @a
    finally
        let @a = a_save
    endtry
endfunction

vmap <C-s> <Esc>:call VisualSource()<cr>

Share the .github file via dropbox and symlink to ~/.github. Source it in using gits new include config

Then get you some hub

This would act as an alternative to Divy / SizeUp. Would love to have something with functionality akin to xmonad.

• phoenix seems like a solid option, highlighly configurable, scriptable in JS
• slate is another solid option, also configurable in JS
• amethyst looks to be similar to xmonad

https://raw.github.com/sgharms/GIFL/

• Needs the ability to prompt for search string
• Default setting for g:LuckFormat (markdown)
• Map customization

Create a completion script that will allow me to tab complete my sessions for ta (tmux attach-session -t ).

Reference the oh-my-zsh plugins list

Look into creating a rake task ala rbates rake install. Break zshrc into separate files.

rbates dotfiles
zach homans dotfiles are meant to be forked blog post
Also ref this blog post: The cleanest vimrc you’ll ever see
Look into YADR - Opinionated dotfiles

https://github.com/tpope/vim-dispatch

Snipmate has moved to a new fork managed by garbas.

UltiSnippets looks like it may be a superior option.

Also consider XPtemplate?

Pure looks to be a very clean, minimal, fast prompt.
Liquid Prompt looks to be more full featured

Also consider implementing slower parts async per this post

It should be able to seek out all configured leader mappings, preferably with where they are from.

• List all current leader mappings
• Highlight any map shadows
• Highlight any map issues

http://www.codeography.com/2013/06/17/replacing-all-the-things-with-unite-vim.html
http://usevim.com/2013/06/19/unite/

https://github.com/AndrewRadev/switch.vim

Vim takes a number of seconds to open when started within tmux. This is not the case outside tmux.

Vim airline is a lightweight option similar to powerline

Another alternative is lightline

Vim-powerline is intense, but requires python and is in the midst of a rewrite

It should be able to seek out all configured leader mappings, preferably with where they are from.

• List all current leader mappings
• Highlight any map shadows (something mapped to two keys, ie <leader>ru, then something else mapped to <leader>run. The <leader>ru map will hang while waiting to see if <leader>run gets typed)
• Highlight any map issues

Update the current ListMapShaddows() function to include both normal and visual mode mappings.

Can we put in something to highlight when one map overwrites another? With my config spread across multiple files I could end up redefining a map in different files.

Steve Losh's post on setting up mutt

Vmail

UltiSnippets blog post w/ screen cast

Snipmate has moved to a new fork managed by garbas.

UltiSnippets looks like it may be a superior option.

Also consider XPtemplate?

Would be nice to have the convenience of indent folding with the control of marker folding. Specifically looking at vimscript as an example of where this would be used, but I think it could be useful all over.

Vim Wiki Folding tips contains a note about how to do this.

I would like to be able to use Command-T to select from arbitrary lists. Based on the various matcher windows (buffer, file, tag, etc) it looks like it should be possible to do to this kind of thing. Browse the issues list to see if this has been discussed before?

The desired API would look something like:

" This function would return a vim list
let headings = ParseHeadingsList()

" This is the desired CommandT interface. It would take a 
" vim list as input and provide the selected item as a return value.
let selectedHeading = CommandTGeneralWindow(headings)

This set of commits should contain a relevant change set to model after.

Map <tab> to jump to next, <S-tab> to previous