# HG changeset patch
# User Steve Losh <steve@stevelosh.com>
# Date 1308929739 14400
# Node ID 16992feb38f3ba626e266f01b6c13c7a0245a93f
# Parent 47adab01cec1bae97f8f279b32db614b5720b936
Vim.
diff -r 47adab01cec1 -r 16992feb38f3 vim/.vimrc
--- a/vim/.vimrc Thu Jun 23 17:10:55 2011 -0400
+++ b/vim/.vimrc Fri Jun 24 11:35:39 2011 -0400
@@ -453,7 +453,10 @@
" Convenience mappings -------------------------------------------------------- {{{
" Clean whitespace
-map <leader>W :%s/\s\+$//<cr>:let @/=''<CR>
+map <leader>W :%s/\s\+$//<cr>:let @/=''<CR>
+
+" Dammit, Slimv
+map <leader>WW :%s/\s\+$//<cr>:let @/=''<CR>
" Change case
nnoremap <C-u> gUiw
diff -r 47adab01cec1 -r 16992feb38f3 vim/plugin/DirDiff.vim
--- a/vim/plugin/DirDiff.vim Thu Jun 23 17:10:55 2011 -0400
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1070 +0,0 @@
-" -*- vim -*-
-" FILE: "/home/wlee/.vim/plugin/DirDiff.vim" {{{
-" LAST MODIFICATION: "Mon, 20 Oct 2008 09:04:59 -0500 (wlee)"
-" HEADER MAINTAINED BY: N/A
-" VERSION: 1.1.2
-" (C) 2001-2006 by William Lee, <wl1012@yahoo.com>
-" }}}
-
-
-" PURPOSE: {{{
-" - Diffing a directory recursively and enable easy merging, copying and
-" deleting of files and directories.
-"
-" REQUIREMENTS:
-" - Make sure you have GNU diff in your path on Unix and Windows. I only
-" tested this on cygwin's version on Windows. If you have a diff that
-" doesn't support -x or -I flag, do not set variable g:DirDiffExcludes and
-" g:DirDiffIgnore to "". It should still work.
-" - On Windows, you need to have "xcopy", "copy", "del", and "rd" in your
-" path.
-" - On Unix, you need to have "rm" and "cp" in your path.
-"
-" USAGE:
-" Put this file in your ~/.vim/plugin
-"
-" Doing the following will generate a diff window.
-"
-" :DirDiff <A:Src Directory> <B:Src Directory>
-" e.g.
-" :DirDiff ../something/dir1 /usr/bin/somethingelse/dir2
-"
-" The following commands can be used inside the diff window:
-" 'Enter','o' - Diff open: open the diff file(s) where your cursor is at
-" 's' - Synchronize the current diff. You can also select
-" a range (through visual) and press 's' to synchronize differences
-" across a range.
-"
-" - There are 6 Options you can choose when you hit 's':
-" 1. A -> B
-" Copy A to overwrite B
-" If A's file actually points to a directory, it'll copy it to B
-" recursively.
-" 2. B -> A
-" Copy B to overwrite A
-" If B's file actually points to a directory, it'll copy it to A
-" recursively.
-" 3. Always A
-" For the rest of the items that you've selected,
-" synchronize like (1).
-" 4. Always B
-" For the rest of the items that you've selected,
-" synchronize like (2).
-" 5. Skip
-" Skip this diff entry.
-" 6. Cancel
-" Quit the loop and exit.
-"
-" 'u' - Diff update: update the diff window
-" 'x' - Sets the exclude pattern, separated by ','
-" 'i' - Sets the ignore pattern, separated by ','
-" 'a' - Sets additional arguments for diff, eg. -w to ignore white space,
-" etc.
-" 'q' - Quit DirDiff
-"
-" The following comamnds can be used in the Vim diff mode
-" \dg - Diff get: maps to :diffget<CR>
-" \dp - Diff put: maps to :diffput<CR>
-" \dj - Diff next: (think j for down)
-" \dk - Diff previous: (think k for up)
-"
-" You can set the following DirDiff variables. You can add the following
-" "let" lines in your .vimrc file.
-"
-" Sets default exclude pattern:
-" let g:DirDiffExcludes = "CVS,*.class,*.exe,.*.swp"
-"
-" Sets default ignore pattern:
-" let g:DirDiffIgnore = "Id:,Revision:,Date:"
-"
-" If DirDiffSort is set to 1, sorts the diff lines.
-" let g:DirDiffSort = 1
-"
-" Sets the diff window (bottom window) height (rows)
-" let g:DirDiffWindowSize = 14
-"
-" Ignore case during diff
-" let g:DirDiffIgnoreCase = 0
-"
-" Dynamically figure out the diff text. If you are using and i18n version
-" of diff, this will try to get the specific diff text during runtime. It's
-" turned off by default. If you are always targetting a specific version of
-" diff, you can turn this off and set the DirDiffText* variables
-" accordingly.
-" let g:DirDiffDynamicDiffText = 0
-"
-" String used for the English equivalent "Files "
-" let g:DirDiffTextFiles = "Files "
-
-" String used for the English equivalent " and "
-" let g:DirDiffTextAnd = " and "
-"
-" String used for the English equivalent " differ")
-" let g:DirDiffTextDiffer = " differ"
-"
-" String used for the English equivalent "Only in ")
-" let g:DirDiffTextOnlyIn = "Only in "
-"
-" NOTES:
-" This script can copy and remove your files. This can be powerful (or too
-" powerful) at times. Please do not blame me if you use this and
-" disintegrate your hard work. Be warned!
-"
-" CREDITS:
-"
-" Please mail any comment/suggestion/patch to
-" William Lee <wl1012@yahoo.com>
-"
-" LICENSE:
-" Copyright (c) 2001-2006 William Lee
-" All rights reserved.
-"
-" Redistribution and use in source and binary forms, with or without
-" modification, are permitted provided that the following conditions are
-" met:
-"
-" * Redistributions of source code must retain the above copyright
-" notice, this list of conditions and the following disclaimer.
-" * Redistributions in binary form must reproduce the above copyright
-" notice, this list of conditions and the following disclaimer in the
-" documentation and/or other materials provided with the distribution.
-" * Neither the name William Lee nor the names of its contributors may be
-" used to endorse or promote products derived from this software without
-" specific prior written permission.
-"
-" THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
-" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-" WILLIAM LEE AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"
-" THANKS:
-"
-" Florian Delizy for the i18n diff patch
-" Robert Webb for his sorting function
-" Salman Halim, Yosuke Kimura, and others for their suggestions
-"
-" HISTORY:
-" 1.1.2 - Applied the patch to 1.1.0 instead of 1.0.2. Please do not use
-" 1.1.1
-" 1.1.1 - Make it work with filename with spaces. (Thanks to Atte Kojo)
-" 1.1.0 - Added support for i18n (tested on a French version for now only).
-" Can dynamically figure out the diff strings output by diff.
-" 1.0.2 - Fixed a small typo bug in the quit function.
-" 1.0.1 - Ensure the path separator is correct when running in W2K
-" 1.0 - Fixed a bug that flags errors if the user use the nowrapscan option.
-" Implements a quit function that exit the diff windows.
-" 0.94 - Fixed a bug where the diff will give incorrect A and B file due to
-" similarity of directory names. Allow you to modify the diff
-" argument.
-" 0.93 - Opps, messed up the key mapping usage.
-" 0.92 - Doesn't use n and p mappings since it confuses the search next key
-" mapping and causes some bugs. Minor modification to change the
-" exclude and ignore pattern.
-" 0.91 - Clean up delete routine.
-" - Added interactive mode.
-" - Added multiple entries of exclude and ignore pattern.
-" - Custom configuration through global variables.
-" - Change exclude and ignore patterns on the fly.
-"
-" 0.9 - Reorganization of the interface. Much simplier dialog for
-" synchronization. Support for range synchronization option (REALLY
-" powerful)
-" - Removed unnecessary key bindings. All key bindings are local to
-" the diff window. (except for the \dg and \dp)
-"
-" 0.8 - Added syntax highlighting.
-" - Enter and double-click in buffer opens diff.
-" - Removed dependency on "sort"
-" - Removed usage of registry and marker
-" - Code cleanup and some bug fixes
-" - On Windows the diff command will use the -i flag instead
-" - Changed mappings for diff next (\dj) and diff previous (\dk)
-" - Added mappings for vim diff mode (\dg, \dp)
-"
-" 0.7 Initial Release
-"
-" }}}
-
-" Public Interface:
-command! -nargs=* -complete=dir DirDiff call <SID>DirDiff (<f-args>)
-command! -nargs=0 DirDiffOpen call <SID>DirDiffOpen ()
-command! -nargs=0 DirDiffNext call <SID>DirDiffNext ()
-command! -nargs=0 DirDiffPrev call <SID>DirDiffPrev ()
-command! -nargs=0 DirDiffUpdate call <SID>DirDiffUpdate ()
-command! -nargs=0 DirDiffQuit call <SID>DirDiffQuit ()
-
-if !hasmapto('<Plug>DirDiffGet')
- map <unique> <Leader>dg <Plug>DirDiffGet
-endif
-if !hasmapto('<Plug>DirDiffPut')
- map <unique> <Leader>dp <Plug>DirDiffPut
-endif
-if !hasmapto('<Plug>DirDiffNext')
- map <unique> <Leader>dj <Plug>DirDiffNext
-endif
-if !hasmapto('<Plug>DirDiffPrev')
- map <unique> <Leader>dk <Plug>DirDiffPrev
-endif
-
-" Global Maps:
-map <unique> <script> <Plug>DirDiffGet :diffget<CR>
-map <unique> <script> <Plug>DirDiffPut :diffput<CR>
-map <unique> <script> <Plug>DirDiffNext :call <SID>DirDiffNext()<CR>
-map <unique> <script> <Plug>DirDiffPrev :call <SID>DirDiffPrev()<CR>
-map <unique> <script> <Plug>DirDiffQuit :call <SID>DirDiffQuit()<CR>
-
-" Default Variables. You can override these in your global variables
-" settings.
-"
-" For DirDiffExcludes and DirDiffIgnore, separate different patterns with a
-" ',' (comma and no space!).
-"
-" eg. in your .vimrc file: let g:DirDiffExcludes = "CVS,*.class,*.o"
-" let g:DirDiffIgnore = "Id:"
-" " ignore white space in diff
-" let g:DirDiffAddArgs = "-w"
-"
-" You can set the pattern that diff excludes. Defaults to the CVS directory
-if !exists("g:DirDiffExcludes")
- let g:DirDiffExcludes = ""
-endif
-" This is the -I argument of the diff, ignore the lines of differences that
-" matches the pattern
-if !exists("g:DirDiffIgnore")
- let g:DirDiffIgnore = ""
-endif
-if !exists("g:DirDiffSort")
- let g:DirDiffSort = 1
-endif
-if !exists("g:DirDiffWindowSize")
- let g:DirDiffWindowSize = 14
-endif
-if !exists("g:DirDiffInteractive")
- let g:DirDiffInteractive = 0
-endif
-if !exists("g:DirDiffIgnoreCase")
- let g:DirDiffIgnoreCase = 0
-endif
-" Additional arguments
-if !exists("g:DirDiffAddArgs")
- let g:DirDiffAddArgs = ""
-endif
-" Support for i18n (dynamically figure out the diff text)
-" Defaults to off
-if !exists("g:DirDiffDynamicDiffText")
- let g:DirDiffDynamicDiffText = 0
-endif
-
-" String used for the English equivalent "Files "
-if !exists("g:DirDiffTextFiles")
- let g:DirDiffTextFiles = "Files "
-endif
-
-" String used for the English equivalent " and "
-if !exists("g:DirDiffTextAnd")
- let g:DirDiffTextAnd = " and "
-endif
-
-" String used for the English equivalent " differ")
-if !exists("g:DirDiffTextDiffer")
- let g:DirDiffTextDiffer = " differ"
-endif
-
-" String used for the English equivalent "Only in ")
-if !exists("g:DirDiffTextOnlyIn")
- let g:DirDiffTextOnlyIn = "Only in "
-endif
-
-" Set some script specific variables:
-"
-let s:DirDiffFirstDiffLine = 6
-let s:DirDiffALine = 1
-let s:DirDiffBLine = 2
-
-" -- Variables used in various utilities
-if has("unix")
- let s:DirDiffCopyCmd = "cp"
- let s:DirDiffCopyFlags = ""
- let s:DirDiffCopyDirCmd = "cp"
- let s:DirDiffCopyDirFlags = "-rf"
- let s:DirDiffCopyInteractiveFlag = "-i"
-
- let s:DirDiffDeleteCmd = "rm"
- let s:DirDiffDeleteFlags = ""
- let s:DirDiffDeleteInteractiveFlag = "-i"
-
- let s:DirDiffDeleteDirCmd = "rm"
- let s:DirDiffDeleteDirFlags = "-rf"
-
- let s:sep = "/"
-
- let s:DirDiffMakeDirCmd = "!mkdir "
-
-elseif has("win32")
- let s:DirDiffCopyCmd = "copy"
- let s:DirDiffCopyFlags = ""
- let s:DirDiffCopyDirCmd = "xcopy"
- let s:DirDiffCopyDirFlags = "/e /i /q"
- let s:DirDiffCopyInteractiveFlag = "/-y"
-
- let s:DirDiffDeleteCmd = "del"
- let s:DirDiffDeleteFlags = "/s /q"
- let s:DirDiffDeleteInteractiveFlag = "/p"
- " Windows is somewhat stupid since "del" can only remove the files, not
- " the directory. The command "rd" would remove files recursively, but it
- " doesn't really work on a file (!). where is the deltree command???
-
- let s:DirDiffDeleteDirCmd = "rd"
- " rd is by default prompting, we need to handle this in a different way
- let s:DirDiffDeleteDirFlags = "/s"
- let s:DirDiffDeleteDirQuietFlag = "/q"
-
- let s:sep = "\\"
-
- let s:DirDiffMakeDirCmd = "!mkdir "
-else
- " Platforms not supported
- let s:DirDiffCopyCmd = ""
- let s:DirDiffCopyFlags = ""
- let s:DirDiffDeleteCmd = ""
- let s:DirDiffDeleteFlags = ""
- let s:sep = ""
-endif
-
-
-function! <SID>DirDiff(srcA, srcB)
- " Setup
- let DirDiffAbsSrcA = fnamemodify(expand(a:srcA, ":p"), ":p")
- let DirDiffAbsSrcB = fnamemodify(expand(a:srcB, ":p"), ":p")
-
- " Check for an internationalized version of diff ?
- call <SID>GetDiffStrings()
-
- " Remove the trailing \ or /
- let DirDiffAbsSrcA = substitute(DirDiffAbsSrcA, '\\$\|/$', '', '')
- let DirDiffAbsSrcB = substitute(DirDiffAbsSrcB, '\\$\|/$', '', '')
-
- let DiffBuffer = tempname()
- " We first write to that file
- " Constructs the command line
- let cmd = "!diff"
- let cmdarg = " -r --brief"
-
- " If variable is set, we ignore the case
- if (g:DirDiffIgnoreCase)
- let cmdarg = cmdarg." -i"
- endif
- if (g:DirDiffAddArgs != "")
- let cmdarg = cmdarg." ".g:DirDiffAddArgs." "
- endif
- if (g:DirDiffExcludes != "")
- let cmdarg = cmdarg.' -x"'.substitute(g:DirDiffExcludes, ',', '" -x"', 'g').'"'
- endif
- if (g:DirDiffIgnore != "")
- let cmdarg = cmdarg.' -I"'.substitute(g:DirDiffIgnore, ',', '" -I"', 'g').'"'
- endif
- " Prompt the user for additional arguments
-" let addarg = input("Additional diff args (current =". cmdarg. "): ")
- let addarg = ""
- let cmd = cmd.cmdarg." ".addarg." \"".DirDiffAbsSrcA."\" \"".DirDiffAbsSrcB."\""
- let cmd = cmd." > \"".DiffBuffer."\""
-
- echo "Diffing directories, it may take a while..."
- let error = <SID>DirDiffExec(cmd, 0)
- if (error == 0)
- echo "There is no diff here."
- return
- endif
- silent exe "edit ".DiffBuffer
- echo "Defining [A] and [B] ... "
- " We then do a substitution on the directory path
- " We need to do substitution of the the LONGER string first, otherwise
- " it'll mix up the A and B directory
- if (strlen(DirDiffAbsSrcA) > strlen(DirDiffAbsSrcB))
- silent! exe "%s/".<SID>EscapeDirForRegex(DirDiffAbsSrcA)."/[A]/"
- silent! exe "%s/".<SID>EscapeDirForRegex(DirDiffAbsSrcB)."/[B]/"
- else
- silent! exe "%s/".<SID>EscapeDirForRegex(DirDiffAbsSrcB)."/[B]/"
- silent! exe "%s/".<SID>EscapeDirForRegex(DirDiffAbsSrcA)."/[A]/"
- endif
- " In windows, diff behaves somewhat weirdly, for the appened path it'll
- " use "/" instead of "\". Convert this to \
- if (has("win32"))
- silent! %s/\//\\/g
- endif
-
- echo "Sorting entries ..."
- " We then sort the lines if the option is set
- if (g:DirDiffSort == 1)
- 1,$call <SID>Sort("s:Strcmp")
- endif
-
- " Put in spacer in front of each line
- silent! %s/^/ /
-
- " We then put the file [A] and [B] on top of the diff lines
- call append(0, "[A]=". DirDiffAbsSrcA)
- call append(1, "[B]=". DirDiffAbsSrcB)
- call append(2, "Usage: <Enter>/'o'=open,'s'=sync,'\\dj'=next,'\\dk'=prev, 'q'=quit")
- call append(3, "Options: 'u'=update,'x'=set excludes,'i'=set ignore,'a'=set args" )
- call append(4, "Diff Args:" . cmdarg)
- call append(5, "")
- " go to the beginning of the file
- 0
- setlocal nomodified
- setlocal nomodifiable
- setlocal buftype=nowrite
- setlocal bufhidden=delete
- setlocal nowrap
-
- " Set up local key bindings
- " 'n' actually messes with the search next pattern, I think using \dj and
- " \dk is enough. Otherwise, use j,k, and enter.
-" nnoremap <buffer> n :call <SID>DirDiffNext()<CR>
-" nnoremap <buffer> p :call <SID>DirDiffPrev()<CR>
- nnoremap <buffer> s :. call <SID>DirDiffSync()<CR>
- vnoremap <buffer> s :call <SID>DirDiffSync()<CR>
- nnoremap <buffer> u :call <SID>DirDiffUpdate()<CR>
- nnoremap <buffer> x :call <SID>ChangeExcludes()<CR>
- nnoremap <buffer> a :call <SID>ChangeArguments()<CR>
- nnoremap <buffer> i :call <SID>ChangeIgnore()<CR>
- nnoremap <buffer> q :call <SID>DirDiffQuit()<CR>
-
- nnoremap <buffer> o :call <SID>DirDiffOpen()<CR>
- nnoremap <buffer> <CR> :call <SID>DirDiffOpen()<CR>
- nnoremap <buffer> <2-Leftmouse> :call <SID>DirDiffOpen()<CR>
- call <SID>SetupSyntax()
-
- " Open the first diff
- call <SID>DirDiffNext()
-endfunction
-
-" Set up syntax highlighing for the diff window
-function! <SID>SetupSyntax()
- if has("syntax") && exists("g:syntax_on")
- "&& !has("syntax_items")
- syn match DirDiffSrcA "\[A\]"
- syn match DirDiffSrcB "\[B\]"
- syn match DirDiffUsage "^Usage.*"
- syn match DirDiffOptions "^Options.*"
- exec 'syn match DirDiffFiles "' . s:DirDiffDifferLine .'"'
- exec 'syn match DirDiffOnly "' . s:DirDiffDiffOnlyLine . '"'
- syn match DirDiffSelected "^==>.*" contains=DirDiffSrcA,DirDiffSrcB
-
- hi def link DirDiffSrcA Directory
- hi def link DirDiffSrcB Type
- hi def link DirDiffUsage Special
- hi def link DirDiffOptions Special
- hi def link DirDiffFiles String
- hi def link DirDiffOnly PreProc
- hi def link DirDiffSelected DiffChange
- endif
-endfunction
-
-" You should call this within the diff window
-function! <SID>DirDiffUpdate()
- let dirA = <SID>GetBaseDir("A")
- let dirB = <SID>GetBaseDir("B")
- call <SID>DirDiff(dirA, dirB)
-endfun
-
-" Quit the DirDiff mode
-function! <SID>DirDiffQuit()
- let in = confirm ("Are you sure you want to quit DirDiff?", "&Yes\n&No", 2)
- if (in == 1)
- call <SID>CloseDiffWindows()
- bd!
- endif
-endfun
-
-" Returns an escaped version of the path for regex uses
-function! <SID>EscapeDirForRegex(path)
- " This list is probably not complete, modify later
- return escape(a:path, "/\\[]$^~")
-endfunction
-
-" Close the opened diff comparison windows if they exist
-function! <SID>CloseDiffWindows()
- if (<SID>AreDiffWinsOpened())
- wincmd k
- " Ask the user to save if buffer is modified
- call <SID>AskIfModified()
- bd!
- " User may just have one window opened, we may not need to close
- " the second diff window
- if (&diff)
- call <SID>AskIfModified()
- bd!
- endif
- endif
-endfunction
-
-
-function! <SID>DirDiffOpen()
- " First dehighlight the last marked
- call <SID>DeHighlightLine()
-
- " Mark the current location of the line
- "mark n
- let b:currentDiff = line(".")
-
- " We first parse back the [A] and [B] directories from the top of the line
- let dirA = <SID>GetBaseDir("A")
- let dirB = <SID>GetBaseDir("B")
-
- call <SID>CloseDiffWindows()
-
- let line = getline(".")
- " Parse the line and see whether it's a "Only in" or "Files Differ"
- call <SID>HighlightLine()
- let fileA = <SID>GetFileNameFromLine("A", line)
- let fileB = <SID>GetFileNameFromLine("B", line)
- if <SID>IsOnly(line)
- " We open the file
- let fileSrc = <SID>ParseOnlySrc(line)
- if (fileSrc == "A")
- let fileToOpen = fileA
- elseif (fileSrc == "B")
- let fileToOpen = fileB
- endif
- split
- wincmd k
- silent exec "edit ".fnameescape(fileToOpen)
- " Fool the window saying that this is diff
- diffthis
- wincmd j
- " Resize the window
- exe("resize " . g:DirDiffWindowSize)
- exe (b:currentDiff)
- elseif <SID>IsDiffer(line)
- "Open the diff windows
- split
- wincmd k
- silent exec "edit ".fnameescape(fileB)
- silent exec "vert diffsplit ".fnameescape(fileA)
- " Go back to the diff window
- wincmd j
- " Resize the window
- exe("resize " . g:DirDiffWindowSize)
- exe (b:currentDiff)
- " Center the line
- exe ("normal z.")
- else
- echo "There is no diff at the current line!"
- endif
-endfunction
-
-" Ask the user to save if the buffer is modified
-"
-function! <SID>AskIfModified()
- if (&modified)
- let input = confirm("File " . expand("%:p") . " has been modified.", "&Save\nCa&ncel", 1)
- if (input == 1)
- w!
- endif
- endif
-endfunction
-
-function! <SID>HighlightLine()
- let savedLine = line(".")
- exe (b:currentDiff)
- setlocal modifiable
- let line = getline(".")
- if (match(line, "^ ") == 0)
- s/^ /==> /
- endif
- setlocal nomodifiable
- setlocal nomodified
- exe (savedLine)
- redraw
-endfunction
-
-function! <SID>DeHighlightLine()
- let savedLine = line(".")
- exe (b:currentDiff)
- let line = getline(".")
- setlocal modifiable
- if (match(line, "^==> ") == 0)
- s/^==> / /
- endif
- setlocal nomodifiable
- setlocal nomodified
- exe (savedLine)
- redraw
-endfunction
-
-" Returns the directory for buffer "A" or "B". You need to be in the diff
-" buffer though.
-function! <SID>GetBaseDir(diffName)
- let currLine = line(".")
- if (a:diffName == "A")
- let baseLine = s:DirDiffALine
- else
- let baseLine = s:DirDiffBLine
- endif
- let regex = '\['.a:diffName.'\]=\(.*\)'
- let line = getline(baseLine)
- let rtn = substitute(line, regex , '\1', '')
- return rtn
-endfunction
-
-function! <SID>DirDiffNext()
- " If the current window is a diff, go down one
- if (&diff == 1)
- wincmd j
- endif
- " if the current line is <= 6, (within the header range), we go to the
- " first diff line open it
- if (line(".") < s:DirDiffFirstDiffLine)
- exe (s:DirDiffFirstDiffLine)
- let b:currentDiff = line(".")
- endif
- silent! exe (b:currentDiff + 1)
- call <SID>DirDiffOpen()
-endfunction
-
-function! <SID>DirDiffPrev()
- " If the current window is a diff, go down one
- if (&diff == 1)
- wincmd j
- endif
- silent! exe (b:currentDiff - 1)
- call <SID>DirDiffOpen()
-endfunction
-
-" For each line, we can perform a recursive copy or delete to sync up the
-" difference. Returns non-zero if the operation is NOT successful, returns 0
-" if everything is fine.
-"
-function! <SID>DirDiffSyncHelper(AB, line)
- let fileA = <SID>GetFileNameFromLine("A", a:line)
- let fileB = <SID>GetFileNameFromLine("B", a:line)
-" echo "Helper line is ". a:line. " fileA " . fileA . " fileB " . fileB
- if <SID>IsOnly(a:line)
- " If a:AB is "A" and the ParseOnlySrc returns "A", that means we need to
- " copy
- let fileSrc = <SID>ParseOnlySrc(a:line)
- let operation = ""
- if (a:AB == "A" && fileSrc == "A")
- let operation = "Copy"
- " Use A, and A has source, thus copy the file from A to B
- let fileFrom = fileA
- let fileTo = fileB
- elseif (a:AB == "A" && fileSrc == "B")
- let operation = "Delete"
- " Use A, but B has source, thus delete the file from B
- let fileFrom = fileB
- let fileTo = fileA
- elseif (a:AB == "B" && fileSrc == "A")
- let operation = "Delete"
- " Use B, but the source file is A, thus removing A
- let fileFrom = fileA
- let fileTo = fileB
- elseif (a:AB == "B" && fileSrc == "B")
- " Use B, and B has the source file, thus copy B to A
- let operation = "Copy"
- let fileFrom = fileB
- let fileTo = fileA
- endif
- elseif <SID>IsDiffer(a:line)
- " Copy no matter what
- let operation = "Copy"
- if (a:AB == "A")
- let fileFrom = fileA
- let fileTo = fileB
- elseif (a:AB == "B")
- let fileFrom = fileB
- let fileTo = fileA
- endif
- else
- echo "There is no diff here!"
- " Error
- return 1
- endif
- if (operation == "Copy")
- let rtnCode = <SID>Copy(fileFrom, fileTo)
- elseif (operation == "Delete")
- let rtnCode = <SID>Delete(fileFrom)
- endif
- return rtnCode
-endfunction
-
-" Synchronize the range
-function! <SID>DirDiffSync() range
- let answer = 1
- let silence = 0
- let syncMaster = "A"
- let currLine = a:firstline
- let lastLine = a:lastline
- let syncCount = 0
-
- while ((currLine <= lastLine))
- " Update the highlight
- call <SID>DeHighlightLine()
- let b:currentDiff = currLine
- call <SID>HighlightLine()
- let line = getline(currLine)
- if (!silence)
- let answer = confirm(substitute(line, "^....", '', ''). "\nSynchronization option:" , "&A -> B\n&B -> A\nA&lways A\nAl&ways B\n&Skip\nCa&ncel", 6)
- if (answer == 1 || answer == 3)
- let syncMaster = "A"
- endif
- if (answer == 2 || answer == 4)
- let syncMaster = "B"
- endif
- if (answer == 3 || answer == 4)
- let silence = 1
- endif
- if (answer == 5)
- let currLine = currLine + 1
- continue
- endif
- if (answer == 6)
- break
- endif
- endif
-
-" call <SID>DeHighlightLine()
- let rtnCode = <SID>DirDiffSyncHelper(syncMaster, line)
- if (rtnCode == 0)
- " Successful
- let syncCount = syncCount + 1
- " Assume that the line is synchronized, we delete the entry
- setlocal modifiable
- exe (currLine.",".currLine." delete")
- setlocal nomodifiable
- setlocal nomodified
- let lastLine = lastLine - 1
- else
- " Failed!
- let currLine = currLine + 1
- endif
- endwhile
- echo syncCount . " diff item(s) synchronized."
-endfunction
-
-" Return file "A" or "B" depending on the line given. If it's a Only line,
-" either A or B does not exist, but the according value would be returned.
-function! <SID>GetFileNameFromLine(AB, line)
- " Determine where the source of the copy is.
- let dirA = <SID>GetBaseDir("A")
- let dirB = <SID>GetBaseDir("B")
-
- let fileToProcess = ""
-
- if <SID>IsOnly(a:line)
- let fileToProcess = <SID>ParseOnlyFile(a:line)
- elseif <SID>IsDiffer(a:line)
- let regex = '^.*' . s:DirDiffDifferLine . '\[A\]\(.*\)' . s:DirDiffDifferAndLine . '\[B\]\(.*\)' . s:DirDiffDifferEndLine . '.*$'
- let fileToProcess = substitute(a:line, regex, '\1', '')
- else
- endif
-
- "echo "line : " . a:line. "AB = " . a:AB . " File to Process " . fileToProcess
- if (a:AB == "A")
- return dirA . fileToProcess
- elseif (a:AB == "B")
- return dirB . fileToProcess
- else
- return ""
- endif
-endfunction
-
-"Returns the source (A or B) of the "Only" line
-function! <SID>ParseOnlySrc(line)
- return substitute(a:line, '^.*' . s:DirDiffDiffOnlyLine . '\[\(.\)\].*:.*', '\1', '')
-endfunction
-
-function! <SID>ParseOnlyFile(line)
- let regex = '^.*' . s:DirDiffDiffOnlyLine . '\[.\]\(.*\): \(.*\)'
- let root = substitute(a:line, regex , '\1', '')
- let file = root . s:sep . substitute(a:line, regex , '\2', '')
- return file
-endfunction
-
-function! <SID>Copy(fileFromOrig, fileToOrig)
- let fileFrom = substitute(a:fileFromOrig, '/', s:sep, 'g')
- let fileTo = substitute(a:fileToOrig, '/', s:sep, 'g')
- echo "Copy from " . fileFrom . " to " . fileTo
- if (s:DirDiffCopyCmd == "")
- echo "Copy not supported on this platform"
- return 1
- endif
-
- " Constructs the copy command
- let copycmd = "!".s:DirDiffCopyCmd." ".s:DirDiffCopyFlags
- " Append the interactive flag
- if (g:DirDiffInteractive)
- let copycmd = copycmd . " " . s:DirDiffCopyInteractiveFlag
- endif
- let copycmd = copycmd . " \"".fileFrom."\" \"".fileTo."\""
-
- " Constructs the copy directory command
- let copydircmd = "!".s:DirDiffCopyDirCmd." ".s:DirDiffCopyDirFlags
- " Append the interactive flag
- if (g:DirDiffInteractive)
- let copydircmd = copydircmd . " " . s:DirDiffCopyInteractiveFlag
- endif
- let copydircmd = copydircmd . " \"".fileFrom."\" \"".fileTo."\""
-
- let error = 0
- if (isdirectory(fileFrom))
- let error = <SID>DirDiffExec(copydircmd, g:DirDiffInteractive)
- else
- let error = <SID>DirDiffExec(copycmd, g:DirDiffInteractive)
- endif
- if (error != 0)
- echo "Can't copy from " . fileFrom . " to " . fileTo
- return 1
- endif
- return 0
-endfunction
-
-" Would execute the command, either silent or not silent, by the
-" interactive flag ([0|1]). Returns the v:shell_error after
-" executing the command.
-function! <SID>DirDiffExec(cmd, interactive)
- let error = 0
- if (a:interactive)
- exe (a:cmd)
- let error = v:shell_error
- else
- silent exe (a:cmd)
- let error = v:shell_error
- endif
-" let d = input("DirDiffExec: " . a:cmd . " " . a:interactive . " returns " . v:shell_error)
- return error
-endfunction
-
-" Delete the file or directory. Returns 0 if nothing goes wrong, error code
-" otherwise.
-function! <SID>Delete(fileFromOrig)
- let fileFrom = substitute(a:fileFromOrig, '/', s:sep, 'g')
- echo "Deleting from " . fileFrom
- if (s:DirDiffDeleteCmd == "")
- echo "Delete not supported on this platform"
- return 1
- endif
-
- let delcmd = ""
-
- if (isdirectory(fileFrom))
- let delcmd = "!".s:DirDiffDeleteDirCmd." ".s:DirDiffDeleteDirFlags
- if (g:DirDiffInteractive)
- " If running on Unix, and we're running in interactive mode, we
- " append the -i tag
- if (has("unix"))
- let delcmd = delcmd . " " . s:DirDiffDeleteInteractiveFlag
- endif
- else
- " If running on windows, and we're not running in interactive
- " mode, we append the quite flag to the "rd" command
- if (has("win32"))
- let delcmd = delcmd . " " . s:DirDiffDeleteDirQuietFlag
- endif
- endif
- else
- let delcmd = "!".s:DirDiffDeleteCmd." ".s:DirDiffDeleteFlags
- if (g:DirDiffInteractive)
- let delcmd = delcmd . " " . s:DirDiffDeleteInteractiveFlag
- endif
- endif
-
- let delcmd = delcmd ." \"".fileFrom."\""
- let error = <SID>DirDiffExec(delcmd, g:DirDiffInteractive)
- if (error != 0)
- echo "Can't delete " . fileFrom
- endif
- return error
-endfunction
-
-function! <SID>AreDiffWinsOpened()
- let currBuff = expand("%:p")
- let currLine = line(".")
- wincmd k
- let abovedBuff = expand("%:p")
- if (&diff)
- let abovedIsDiff = 1
- else
- let abovedIsDiff = 0
- endif
- " Go Back if the aboved buffer is not the same
- if (currBuff != abovedBuff)
- wincmd j
- " Go back to the same line
- exe (currLine)
- if (abovedIsDiff == 1)
- return 1
- else
- " Aboved is just a bogus buffer, not a diff buffer
- return 0
- endif
- else
- exe (currLine)
- return 0
- endif
-endfunction
-
-" The given line begins with the "Only in"
-function! <SID>IsOnly(line)
- return (match(a:line, "^ *" . s:DirDiffDiffOnlyLine . "\\|^==> " . s:DirDiffDiffOnlyLine ) == 0)
-endfunction
-
-" The given line begins with the "Files"
-function! <SID>IsDiffer(line)
- return (match(a:line, "^ *" . s:DirDiffDifferLine . "\\|^==> " . s:DirDiffDifferLine ) == 0)
-endfunction
-
-" Let you modify the Exclude patthern
-function! <SID>ChangeExcludes()
- let g:DirDiffExcludes = input ("Exclude pattern (separate multiple patterns with ','): ", g:DirDiffExcludes)
- echo "\nPress update ('u') to refresh the diff."
-endfunction
-
-" Let you modify additional arguments for diff
-function! <SID>ChangeArguments()
- let g:DirDiffAddArgs = input ("Additional diff args: ", g:DirDiffAddArgs)
- echo "\nPress update ('u') to refresh the diff."
-endfunction
-
-" Let you modify the Ignore patthern
-function! <SID>ChangeIgnore()
- let g:DirDiffIgnore = input ("Ignore pattern (separate multiple patterns with ','): ", g:DirDiffIgnore)
- echo "\nPress update ('u') to refresh the diff."
-endfunction
-
-" Sorting functions from the Vim docs. Use this instead of the sort binary.
-"
-" Function for use with Sort(), to compare two strings.
-func! <SID>Strcmp(str1, str2)
- if (a:str1 < a:str2)
- return -1
- elseif (a:str1 > a:str2)
- return 1
- else
- return 0
- endif
-endfunction
-
-" Sort lines. SortR() is called recursively.
-func! <SID>SortR(start, end, cmp)
- if (a:start >= a:end)
- return
- endif
- let partition = a:start - 1
- let middle = partition
- let partStr = getline((a:start + a:end) / 2)
- let i = a:start
- while (i <= a:end)
- let str = getline(i)
- exec "let result = " . a:cmp . "(str, partStr)"
- if (result <= 0)
- " Need to put it before the partition. Swap lines i and partition.
- let partition = partition + 1
- if (result == 0)
- let middle = partition
- endif
- if (i != partition)
- let str2 = getline(partition)
- call setline(i, str2)
- call setline(partition, str)
- endif
- endif
- let i = i + 1
- endwhile
-
- " Now we have a pointer to the "middle" element, as far as partitioning
- " goes, which could be anywhere before the partition. Make sure it is at
- " the end of the partition.
- if (middle != partition)
- let str = getline(middle)
- let str2 = getline(partition)
- call setline(middle, str2)
- call setline(partition, str)
- endif
- call <SID>SortR(a:start, partition - 1, a:cmp)
- call <SID>SortR(partition + 1, a:end, a:cmp)
-endfunc
-
-" To Sort a range of lines, pass the range to Sort() along with the name of a
-" function that will compare two lines.
-func! <SID>Sort(cmp) range
- call <SID>SortR(a:firstline, a:lastline, a:cmp)
-endfunc
-
-" Added to deal with internationalized version of diff, which returns a
-" different string than "Files ... differ" or "Only in ... "
-
-function! <SID>GetDiffStrings()
- " Check if we have the dynamic text string turned on. If not, just return
- " what's set in the global variables
-
- if (g:DirDiffDynamicDiffText == 0)
- let s:DirDiffDiffOnlyLine = g:DirDiffTextOnlyIn
- let s:DirDiffDifferLine = g:DirDiffTextFiles
- let s:DirDiffDifferAndLine = g:DirDiffTextAnd
- let s:DirDiffDifferEndLine = g:DirDiffTextDiffer
- return
- endif
-
- let tmp1 = tempname()
- let tmp2 = tempname()
- let tmpdiff = tempname()
-
- " We need to pad the backslashes in order to make it match
- let tmp1rx = <SID>EscapeDirForRegex(tmp1)
- let tmp2rx = <SID>EscapeDirForRegex(tmp2)
- let tmpdiffrx = <SID>EscapeDirForRegex(tmpdiff)
-
- silent exe s:DirDiffMakeDirCmd . "\"" . tmp1 . "\""
- silent exe s:DirDiffMakeDirCmd . "\"" . tmp2 . "\""
- silent exe "!echo test > \"" . tmp1 . s:sep . "test" . "\""
- silent exe "!diff -r --brief \"" . tmp1 . "\" \"" . tmp2 . "\" > \"" . tmpdiff . "\""
-
- " Now get the result of that diff cmd
- silent exe "split ". tmpdiff
- "echo "First line: " . getline(1)
- "echo "tmp1: " . tmp1
- "echo "tmp1rx: " . tmp1rx
- let s:DirDiffDiffOnlyLine = substitute( getline(1), tmp1rx . ".*$", "", '')
- "echo "DirDiff Only: " . s:DirDiffDiffOnlyLine
-
- q
-
- " Now let's get the Differ string
- "echo "Getting the diff in GetDiffStrings"
-
- silent exe "!echo testdifferent > \"" . tmp2 . s:sep . "test" . "\""
- silent exe "!diff -r --brief \"" . tmp1 . "\" \"" . tmp2 . "\" > \"" . tmpdiff . "\""
-
- silent exe "split ". tmpdiff
- let s:DirDiffDifferLine = substitute( getline(1), tmp1rx . ".*$", "", '')
- " Note that the diff on cygwin may output '/' instead of '\' for the
- " separator, so we need to accomodate for both cases
- let andrx = "^.*" . tmp1rx . "[\\\/]test\\(.*\\)" . tmp2rx . "[\\\/]test.*$"
- let endrx = "^.*" . tmp1rx . "[\\\/]test.*" . tmp2rx . "[\\\/]test\\(.*$\\)"
- "echo "andrx : " . andrx
- "echo "endrx : " . endrx
- let s:DirDiffDifferAndLine = substitute( getline(1), andrx , "\\1", '')
- let s:DirDiffDifferEndLine = substitute( getline(1), endrx, "\\1", '')
-
- "echo "s:DirDiffDifferLine = " . s:DirDiffDifferLine
- "echo "s:DirDiffDifferAndLine = " . s:DirDiffDifferAndLine
- "echo "s:DirDiffDifferEndLine = " . s:DirDiffDifferEndLine
-
- q
-
- " Delete tmp files
- "echo "Deleting tmp files."
-
- call <SID>Delete(tmp1)
- call <SID>Delete(tmp2)
- call <SID>Delete(tmpdiff)
-
-endfunction