├── .gitignore
├── README.md
├── doc
    └── git-arglist.txt
└── plugin
    └── git-arglist.vim


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Swap
 2 | [._]*.s[a-v][a-z]
 3 | !*.svg  # comment out if you don't need vector files
 4 | [._]*.sw[a-p]
 5 | [._]s[a-rt-v][a-z]
 6 | [._]ss[a-gi-z]
 7 | [._]sw[a-p]
 8 | 
 9 | # Session
10 | Session.vim
11 | Sessionx.vim
12 | 
13 | # Temporary
14 | .netrwhist
15 | *~
16 | # Auto-generated tag files
17 | tags
18 | # Persistent undo
19 | [._]*.un~
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # vim-git-arglist
 2 | 
 3 | A plugin which adds helper commands for manipulating the arglist based on the
 4 | current Git repository.
 5 | 
 6 | Vi/Vim's arglist is useful for grouping together a collection of files for easy
 7 | navigation. This plugin adds helper commands that interface with Git for
 8 | manipulating the arglist based on the repository you're working with.
 9 | 
10 | As a quick example, you can add all of the files modified/added by a particular
11 | commit to the arglist with `:ArgsTreeish <commit_hash>`. Or, you can add all of
12 | the files modified/created in your working tree to the arglist using
13 | `:ArgsDiffed`. For more, check out `:h git-arglist-example-workflow`, which
14 | explains one of my personal workflows with this plugin.
15 | 
16 | You can also use `:h git-arglist` for help.
17 | 
18 | # Installation
19 | 
20 | The plugin is plain Vimscript, so the installation doesn't require anything
21 | special. You can install the plugin using whichever plugin manager you normally
22 | use. For example, if you use vim-plug, add:
23 | 
24 | ```
25 | Plug 'joechrisellis/vim-git-arglist'
26 | ```
27 | 
28 | to your vimrc.
29 | 
30 | # Examples
31 | 
32 | You can take full advantage of Git pathspecs with vim-git-arglist:
33 | 
34 | - `:ArgsDiffed HEAD :/'**'.{cpp,h}` -- open all C++ source/header files that
35 |   have changed in the working tree. Strictly, this means "set the arglist to
36 |   all files modified in the working tree with extension `.cpp` and `.h`".
37 | - `:ArgsTreeish <commit> ':**/test/**'` -- open all tests touched by
38 |   `<commit>`. Strictly, this means "set the arglist to all files in the
39 |   repository touched by `<commit>` that are beneath a `test` subdirectory".
40 | - `:ArgsTreeish <commit> ':!/**/docs/**'` -- open everything touched by
41 |   `<commit>` except for documentation changes. Strictly, this means "set the
42 |   arglist to all files in the repository touched by `<commit>` that are not
43 |   beneath a `docs` subdirectory".
44 | 
45 | You can also take advantage of Git revision specifiers:
46 | 
47 | - `:ArgsDiffed @{u}` -- open all of the files that have been modified on the
48 |   current branch since the last push to upstream. If you want to exclude
49 |   uncommitted changes in your working directory, you can use
50 |   `:ArgsDiffed @{u}..`.
51 | 
52 | # License
53 | 
54 | Copyright (c) Joe Ellis. Distributed under the same terms as Vim itself. See
55 | `:help license`.
56 | 


--------------------------------------------------------------------------------
/doc/git-arglist.txt:
--------------------------------------------------------------------------------
  1 | *git-arglist.txt*  Git helpers for manipulating the arglist.
  2 | 
  3 | Author:  Joe Ellis
  4 | License: Same terms as Vim itself (see |license|)
  5 | 
  6 | 
  7 | INTRODUCTION                                    *git-arglist*
  8 | 
  9 | This plugin adds helper commands for manipulating the arglist based on the
 10 | current Git repository.
 11 | 
 12 | 
 13 | COMMANDS                                        *git-arglist-commands*
 14 | 
 15 | The plugin provides a collection of commands for manipulating the arglist
 16 | based on the current Git repository. Where possible, these commands try to
 17 | remain faithful to the semantics of the standard Vim builtin commands for
 18 | arglist manipulation.
 19 | 
 20 | There are currently six main contexts:
 21 | 
 22 | - Treeish commands, which modify the arglist based on a treeish (for example,
 23 |   a commit). |git-arglist-treeish-commands| for more information.
 24 | 
 25 | - Diffed commands, which modify the arglist based on files containing unstaged
 26 |   changes in the working tree (or based on a Git revision/range specifier).
 27 |   |git-arglist-diffed-commands| for more information.
 28 | 
 29 | - Tracked commands, which modify the arglist based on files tracked by Git.
 30 |   |git-arglist-tracked-commands| for more information.
 31 | 
 32 | - Untracked commands, which modify the arglist based on untracked files in the
 33 |   working tree. |git-arglist-untracked-commands| for more information.
 34 | 
 35 | - Staged commands, which modify the arglist based on files containing staged
 36 |   changes. |git-arglist-staged-commands| for more information.
 37 | 
 38 | - Conflicted commands, which modify the arglist based on conflicted files in
 39 |   the working tree. |git-arglist-conflicted-commands| for more information.
 40 | 
 41 | For each of these contexts, the following variants exist:
 42 | 
 43 | - |:Args...|, which works like the |:args| builtin command.
 44 | 
 45 | - |:Argl...|, which works like the |:argl| builtin command.
 46 | 
 47 | - |:ArgAdd...|, which works like the |:argadd| builtin command.
 48 | 
 49 | - |:ArgDelete...|, which works like the |:argdelete| builtin command.
 50 | 
 51 | - |:ArgEdit...|, which works like the |:argedit| builtin command.
 52 | 
 53 |                                                 *git-arglist-bang*
 54 | You can give a bang [!] to some of the command variants. This causes the
 55 | plugin to use the corresponding builtin command with a bang.
 56 | 
 57 |                                                 *git-arglist-pathspec-behaviour*
 58 | Commands accept an optional pathspec parameter. Specifying this parameter
 59 | allows you to whittle down targeted files. If this parameter is omitted, the
 60 | default behaviour is for no filtering to be performed and for all of the files
 61 | inside the repository to be considered.
 62 | 
 63 | For example, to set the arglist to all tracked files in the repository, use:
 64 | >
 65 |     :ArgsTracked
 66 | <
 67 | ... but to set the arglist to only the tracked files inside the `foo`
 68 | subdirectory:
 69 | >
 70 |     :ArgsTracked foo
 71 | <
 72 | 
 73 | TREEISH COMMANDS                                *git-arglist-treeish-commands*
 74 | 
 75 |                                                 *:ArgsTreeish*
 76 | :ArgsTreeish[!] {treeish} {pathspec}
 77 | 
 78 | Set the arglist to the files described by {pathspec} that are created/modified
 79 | by {treeish} (with respect to its parent(s)).
 80 | 
 81 | Both {treeish} and {pathspec} may be omitted. If {treeish} is omitted, `HEAD`
 82 | will be used. If {pathspec} is omitted, all created/modified files in the
 83 | repository will be added to the arglist.
 84 | 
 85 |                                                 *:ArglTreeish*
 86 | :ArglTreeish[!] {treeish} {pathspec}
 87 | 
 88 | Same as |:ArgsTreeish|, but use the local arglist.
 89 | 
 90 |                                                 *:ArgAddTreeish*
 91 | :ArgAddTreeish {treeish} {pathspec}
 92 | 
 93 | Same as |:ArgsTreeish|, but add to the arglist rather than setting it.
 94 | 
 95 |                                                 *:ArgDeleteTreeish*
 96 | :ArgDeleteTreeish {treeish} {pathspec}
 97 | 
 98 | Same as |:ArgsTreeish|, but delete from the arglist rather than setting it.
 99 | 
100 |                                                 *:ArgEditTreeish*
101 | :ArgEditTreeish[!] {treeish} {pathspec}
102 | 
103 | Same as |:ArgAddTreeish|, but also edit the files.
104 | 
105 | 
106 | DIFFED COMMANDS                                 *git-arglist-diffed-commands*
107 | 
108 |                                                 *:ArgsDiffed*
109 | :ArgsDiffed[!] {gitrevision} {pathspec}
110 | 
111 | Set the arglist to the files described by {pathspec} that are listed as
112 | touched by the revision/range specifier {gitrevision}.
113 | 
114 | Both {gitrevision} and {pathspec} may be omitted. If {gitrevision} is omitted,
115 | `HEAD` will be used (corresponding to the files containing unstaged changes in
116 | the working tree). If {pathspec} is omitted, all files in the repository
117 | described by {gitrevision} will will be added to the arglist.
118 | 
119 |                                                 *:ArglDiffed*
120 | :ArglDiffed[!] {gitrevision} {pathspec}
121 | 
122 | Same as |:ArgsDiffed|, but use the local arglist.
123 | 
124 |                                                 *:ArgAddDiffed*
125 | :ArgAddDiffed {gitrevision} {pathspec}
126 | 
127 | Same as |:ArgsDiffed|, but add to the arglist rather than setting it.
128 | 
129 |                                                 *:ArgDeleteDiffed*
130 | :ArgDeleteDiffed {gitrevision} {pathspec}
131 | 
132 | Same as |:ArgsDiffed|, but delete from the arglist rather than setting it.
133 | 
134 |                                                 *:ArgEditDiffed*
135 | :ArgEditDiffed[!] {gitrevision} {pathspec}
136 | 
137 | Same as |:ArgAddDiffed|, but also edit the files.
138 | 
139 | 
140 | TRACKED COMMANDS                                *git-arglist-tracked-commands*
141 | 
142 |                                                 *:ArgsTracked*
143 | :ArgsTracked[!] {pathspec}
144 | 
145 | Set the arglist to the tracked files described by {pathspec}.
146 | 
147 | {pathspec} may be omitted. If {pathspec} is omitted all tracked files in the
148 | repository will be added to the arglist.
149 | 
150 |                                                 *:ArglTracked*
151 | :ArglTracked[!] {pathspec}
152 | 
153 | Same as |:ArgsTracked|, but use the local arglist.
154 | 
155 |                                                 *:ArgAddTracked*
156 | :ArgAddTracked {pathspec}
157 | 
158 | Same as |:ArgsTracked|, but add to the arglist rather than setting it.
159 | 
160 |                                                 *:ArgDeleteTracked*
161 | :ArgDeleteTracked {pathspec}
162 | 
163 | Same as |:ArgsTracked|, but delete from the arglist rather than setting it.
164 | 
165 |                                                 *:ArgEditTracked*
166 | :ArgEditTracked[!] {pathspec}
167 | 
168 | Same as |:ArgAddTracked|, but also edit the files.
169 | 
170 | 
171 | UNTRACKED COMMANDS                              *git-arglist-untracked-commands*
172 | 
173 | WARNING: If you don't specify a {pathspec} for the commands below, they will
174 |          capture all of the untracked files in your working tree. Use with
175 |          with caution if your build directory lives inside your working tree!
176 | 
177 |                                                 *:ArgsUntracked*
178 | :ArgsUntracked[!] {pathspec}
179 | 
180 | Set the arglist to the untracked files described by {pathspec}.
181 | 
182 | {pathspec} may be omitted. If {pathspec} is omitted all untracked files in the
183 | repository will be added to the arglist.
184 | 
185 |                                                 *:ArglUntracked*
186 | :ArglUntracked[!] {pathspec}
187 | 
188 | Same as |:ArgsUntracked|, but use the local arglist.
189 | 
190 |                                                 *:ArgAddUntracked*
191 | :ArgAddUntracked {pathspec}
192 | 
193 | Same as |:ArgsUntracked|, but add to the arglist rather than setting it.
194 | 
195 |                                                 *:ArgDeleteUntracked*
196 | :ArgDeleteUntracked {pathspec}
197 | 
198 | Same as |:ArgsUntracked|, but delete from the arglist rather than setting it.
199 | 
200 |                                                 *:ArgEditUntracked*
201 | :ArgEditUntracked[!] {pathspec}
202 | 
203 | Same as |:ArgAddUntracked|, but also edit the files.
204 | 
205 | 
206 | STAGED COMMANDS                                 *git-arglist-staged-commands*
207 | 
208 |                                                 *:ArgsStaged*
209 | :ArgsStaged[!] {pathspec}
210 | 
211 | Set the arglist to the files described by {pathspec} that contain changes in
212 | the stage.
213 | 
214 | {pathspec} may be omitted. If {pathspec} is omitted, all files containing
215 | staged changes in the repository will be added to the arglist.
216 | 
217 |                                                 *:ArglStaged*
218 | :ArglStaged[!] {pathspec}
219 | 
220 | Same as |:ArgsStaged|, but use the local arglist.
221 | 
222 |                                                 *:ArgAddStaged*
223 | :ArgAddStaged {pathspec}
224 | 
225 | Same as |:ArgsStaged|, but add to the arglist rather than setting it.
226 | 
227 |                                                 *:ArgDeleteStaged*
228 | :ArgDeleteStaged {pathspec}
229 | 
230 | Same as |:ArgsStaged|, but delete from the arglist rather than setting it.
231 | 
232 |                                                 *:ArgEditStaged*
233 | :ArgEditStaged[!] {pathspec}
234 | 
235 | Same as |:ArgAddStaged|, but also edit the files.
236 | 
237 | 
238 | CONFLICTED COMMANDS                             *git-arglist-conflicted-commands*
239 | 
240 |                                                 *:ArgsConflicted*
241 | :ArgsConflicted[!] {pathspec}
242 | 
243 | Set the arglist to the files described by {pathspec} that are conflicted in
244 | the working tree.
245 | 
246 | {pathspec} may be omitted. If {pathspec} is omitted all files in the
247 | repository containing conflicts will be added to the arglist.
248 | 
249 |                                                 *:ArglConflicted*
250 | :ArglConflicted[!] {pathspec}
251 | 
252 | Same as |:ArgsConflicted|, but use the local arglist.
253 | 
254 |                                                 *:ArgAddConflicted*
255 | :ArgAddConflicted {pathspec}
256 | 
257 | Same as |:ArgsConflicted|, but add to the arglist rather than setting it.
258 | 
259 |                                                 *:ArgDeleteConflicted*
260 | :ArgDeleteConflicted {pathspec}
261 | 
262 | Same as |:ArgsConflicted|, but delete from the arglist rather than setting it.
263 | 
264 |                                                 *:ArgEditConflicted*
265 | :ArgEditConflicted[!] {pathspec}
266 | 
267 | Same as |:ArgAddConflicted|, but also edit the files.
268 | 
269 | 
270 | VIMSCRIPT FUNCTIONS                             *git-arglist-vimscript-functions*
271 | 
272 | The plugin exposes the following Vimscript functions:
273 | 
274 | - `TreeishFiles({treeish}, {pathspec}...)` -- returns a list of the files
275 |   described by {pathspec} that are created/modified by {treeish} (with respect
276 |   to its parent(s)).
277 | 
278 | - `DiffedFiles({gitrevision}, {pathspec}...)` -- returns a list of the files
279 |   described by {pathspec} that are listed as touched by the revision/range
280 |   specifier {gitrevision}.
281 | 
282 | - `TrackedFiles({pathspec}...)` -- returns a list of the tracked files
283 |   described by {pathspec}.
284 | 
285 | - `UntrackedFiles({pathspec}...)` -- returns a list of the untracked files
286 |   described by {pathspec}.
287 | 
288 | - `StagedFiles({pathspec}...)` -- returns a list of the files described by
289 |   {pathspec} that contain changes in the stage.
290 | 
291 | - `ConflictedFiles({pathspec}...)` -- returns a list of the files described by
292 |   {pathspec} that are conflicted in the working tree.
293 | 
294 | These are exposed for flexibility. You can use them in backtick expansion (see
295 | |`=|), which opens up a world of possibilities. Be creative!
296 | 
297 | 
298 | EXAMPLE WORKFLOW                                *git-arglist-example-workflow*
299 | 
300 | I will use the LLVM codebase as an example.
301 | 
302 | One thing that I have found this plugin particularly useful for is code
303 | review. When I'm doing a code review, I like to have the modified/added source
304 | files open in one Vim tab, and the modified/added tests open in another. To
305 | achieve this, after creating a local copy of a patch, I use:
306 | >
307 |     :ArglTreeish HEAD :!{llvm,clang}/test
308 |     :tabnew +ArglTreeish\ HEAD\ {llvm,clang}/test
309 | <
310 | The first command sets the local arglist of the current window to all of the
311 | modified/added files that are not in the `llvm/test` or `clang/test` trees.
312 | The second command creates a new tab, and sets the local arglist for the new
313 | window to be the modified/added tests inside the `llvm/test` and `clang/test`
314 | trees.
315 | 
316 | Having the tests in a local arglist like this is super useful because it
317 | allows me to run them all using Vim's built-in terminal. I have the following
318 | mapping in my vimrc:
319 | >
320 |     tnoremap <expr> ;## expand("##")
321 | <
322 | ... so that typing `;##` inside of a terminal window expands to the files in
323 | the arglist. Therefore, if I want to run all of the tests, I can open a
324 | terminal window and type something like:
325 | >
326 |     llvm-lit ;##
327 | <
328 | ... which will be expanded to the full names of the test files!
329 | 
330 | 
331 | FAQ                                             *git-arglist-faq*
332 | 
333 | Q) Can I load diff hunks into the quickfix list with this plugin?
334 | A) No. If you want to do that, a good option is the |fugitive| plugin by Tim
335 |    Pope.
336 | 
337 |     https://github.com/tpope/vim-fugitive
338 | 
339 |    You can jump to diff hunks via the quickfix list with that plugin by using
340 |    the `:Git difftool` command.
341 | 
342 | 
343 | ISSUES                                          *git-arglist-issues*
344 | 
345 | - The commands above may not function correctly if your current working
346 |   directory is symlink to a subdirectory within the Git repository.
347 | 
348 |  vim:tw=78:ts=8:ft=help:norl:
349 | 


--------------------------------------------------------------------------------
/plugin/git-arglist.vim:
--------------------------------------------------------------------------------
  1 | " Git helpers for modifying the arglist.
  2 | " Last Change: 2021 July 27
  3 | " Maintainer: Joe Ellis <joechrisellis@gmail.com>
  4 | 
  5 | if exists("g:loaded_git_arglist")
  6 |   finish
  7 | endif
  8 | let g:loaded_git_arglist = 1
  9 | 
 10 | function! s:Git(git_args)
 11 |   let l:result_lines = systemlist("git " . a:git_args)
 12 |   if v:shell_error != 0
 13 |     throw "Git exited with non-zero exit code."
 14 |   endif
 15 |   return l:result_lines
 16 | endfunction
 17 | 
 18 | function! s:GetWorktreeToplevel()
 19 |   let l:toplevel = s:Git("rev-parse --show-toplevel")[0]
 20 |   return l:toplevel
 21 | endfunction
 22 | 
 23 | function! s:InGitRepo()
 24 |   call system("git rev-parse HEAD >/dev/null 2>&1")
 25 |   return v:shell_error == 0
 26 | endfunction
 27 | 
 28 | let g:treeish_git_flags = "-m --no-commit-id --name-only --diff-filter d -r"
 29 | function! g:TreeishFiles(...)
 30 |   let l:treeish = get(a:, 1, "HEAD")
 31 |   let l:pathspec = a:000[1:]
 32 |   let l:toplevel = s:GetWorktreeToplevel()
 33 |   let l:paths = s:Git(
 34 |         \ "diff-tree "
 35 |         \ . g:treeish_git_flags . " "
 36 |         \ . "'" . l:treeish . "' "
 37 |         \ . "-- "
 38 |         \ . join(l:pathspec, " "))
 39 |   call map(l:paths, "l:toplevel . '/' . v:val")
 40 |   return l:paths
 41 | endfunction
 42 | 
 43 | let g:diffed_git_flags = "--name-only --diff-filter d"
 44 | function! g:DiffedFiles(...)
 45 |   let l:gitrevision = get(a:, 1, "")
 46 |   let l:pathspec = a:000[1:]
 47 |   let l:toplevel = s:GetWorktreeToplevel()
 48 |   let l:paths = s:Git(
 49 |         \ "diff "
 50 |         \ . g:diffed_git_flags . " "
 51 |         \ . l:gitrevision . " "
 52 |         \ . "-- "
 53 |         \ . join(l:pathspec, " "))
 54 |   call map(l:paths, "l:toplevel . '/' . v:val")
 55 |   return l:paths
 56 | endfunction
 57 | 
 58 | let g:tracked_git_flags = "--full-name"
 59 | function! g:TrackedFiles(...)
 60 |   let l:pathspec = a:000[0:]
 61 |   if empty(l:pathspec)
 62 |     let l:pathspec = ["':/'"]
 63 |   endif
 64 | 
 65 |   let l:toplevel = s:GetWorktreeToplevel()
 66 |   let l:paths = s:Git(
 67 |         \ "ls-files "
 68 |         \ . g:tracked_git_flags . " "
 69 |         \ . "-- "
 70 |         \ . join(l:pathspec, " "))
 71 |   call map(l:paths, "l:toplevel . '/' . v:val")
 72 |   return l:paths
 73 | endfunction
 74 | 
 75 | let g:untracked_git_flags = "--full-name --others --exclude-standard"
 76 | function! g:UntrackedFiles(...)
 77 |   let l:pathspec = a:000[0:]
 78 |   if empty(l:pathspec)
 79 |     let l:pathspec = ["':/'"]
 80 |   endif
 81 | 
 82 |   let l:toplevel = s:GetWorktreeToplevel()
 83 |   let l:paths = s:Git(
 84 |         \ "ls-files "
 85 |         \ . g:untracked_git_flags . " "
 86 |         \ . "-- "
 87 |         \ . join(l:pathspec, " "))
 88 |   call map(l:paths, "l:toplevel . '/' . v:val")
 89 |   return l:paths
 90 | endfunction
 91 | 
 92 | let g:staged_git_flags = "--cached --name-only --diff-filter d"
 93 | function! g:StagedFiles(...)
 94 |   let l:toplevel = s:GetWorktreeToplevel()
 95 |   let l:paths = s:Git(
 96 |         \ "diff "
 97 |         \ . g:staged_git_flags . " "
 98 |         \ . "-- "
 99 |         \ . join(a:000, " "))
100 |   call map(l:paths, "l:toplevel . '/' . v:val")
101 |   return l:paths
102 | endfunction
103 | 
104 | let g:conflicted_git_flags = "--name-only --diff-filter U"
105 | function! g:ConflictedFiles(...)
106 |   let l:toplevel = s:GetWorktreeToplevel()
107 |   let l:paths = s:Git(
108 |         \ "diff "
109 |         \ . g:conflicted_git_flags . " "
110 |         \ . "-- "
111 |         \ . join(a:000, " "))
112 |   call map(l:paths, "l:toplevel . '/' . v:val")
113 |   return l:paths
114 | endfunction
115 | 
116 | function! s:CommandWrapper(ContextFunction, arglist_cmd, bang, args)
117 |   if !s:InGitRepo()
118 |     echohl ErrorMsg | echo "Not in a git repo!" | echohl None
119 |     return
120 |   endif
121 | 
122 |   let l:args_expanded_list = split(expand(a:args))
123 | 
124 |   if a:bang
125 |     let a:arglist_cmd .= "!"
126 |   endif
127 | 
128 |   let l:files = []
129 |   try
130 |     let l:files = call(a:ContextFunction, l:args_expanded_list)
131 |   catch /.*/
132 |     echohl ErrorMsg | echo "Caught error: " . v:exception | echohl None
133 |   endtry
134 | 
135 |   if !empty(l:files)
136 |     exe a:arglist_cmd . " " . join(l:files, " ")
137 |   else
138 |     echohl WarningMsg | echo "No files found." | echohl None
139 |   endif
140 | endfunction
141 | 
142 | function! s:CompleteGitBranch(A, L, P)
143 |   try
144 |     let l:branches = s:Git("branch -a")
145 |   catch /.*/
146 |     return []
147 |   endtry
148 | 
149 |   " The magic below demangles the Git output.
150 |   " Something like this:
151 |   "     * master
152 |   "       remotes/origin/HEAD -> origin/master
153 |   "       remotes/origin/master
154 |   "
155 |   " becomes:
156 |   "     master
157 |   "     origin/HEAD
158 |   "     origin/master
159 |   call map(l:branches, "substitute(v:val, '^*', ' ', '')")
160 |   call map(l:branches, "substitute(v:val, '\\s*\\(\\S\\+\\).*', '\\1', '')")
161 |   call map(l:branches, "substitute(v:val, '^remotes/', '', '')")
162 | 
163 |   " Then filter by what the user asked for.
164 |   call filter(l:branches, "v:val =~ a:A")
165 |   return l:branches
166 | endfunction
167 | 
168 | function! s:CompleteRefThenPath(A, L, P)
169 |   let l:num_spaces = count(substitute(a:L, " \\{2,\\}", " ", "g"), " ")
170 |   if l:num_spaces <= 1
171 |     " Branch completion for the first argument.
172 |     return s:CompleteGitBranch(a:A, a:L, a:P)
173 |   else
174 |     " File completion for the other arguments.
175 |     return getcompletion(a:A, "file")
176 |   endif
177 | endfunction
178 | 
179 | let s:context_dict = {
180 |       \ "Treeish" : ["-nargs=*", "-complete=customlist,s:CompleteRefThenPath"],
181 |       \ "Diffed" : ["-nargs=*", "-complete=customlist,s:CompleteRefThenPath"],
182 |       \ "Tracked" : ["-nargs=*", "-complete=customlist,s:CompleteRefThenPath"],
183 |       \ "Untracked" : ["-nargs=*", "-complete=file"],
184 |       \ "Staged" : ["-nargs=*", "-complete=file"],
185 |       \ "Conflicted" : ["-nargs=*", "-complete=file"],
186 |       \ }
187 | 
188 | let s:args_cmd_dict = {
189 |       \ "Args" : ["-bang"],
190 |       \ "Argl" : ["-bang"],
191 |       \ "ArgAdd" : [],
192 |       \ "ArgDelete" : [],
193 |       \ "ArgEdit" : ["-bang"],
194 |       \ }
195 | 
196 | for s:args_cmd_dict_entry in items(s:args_cmd_dict)
197 |   let s:prefix = s:args_cmd_dict_entry[0]
198 |   let s:flags_a = s:args_cmd_dict_entry[1]
199 | 
200 |   for s:context_dict_entry in items(s:context_dict)
201 |     let s:context = s:context_dict_entry[0]
202 |     let s:flags_b = s:context_dict_entry[1]
203 | 
204 |     let s:cmd = s:prefix . s:context
205 |     let s:flags = join(s:flags_a + s:flags_b, " ")
206 |     exe "command! " . s:flags . " " . s:cmd . " :call s:CommandWrapper('g:" . s:context . "Files', '" . tolower(s:prefix) . "', <bang>0, <q-args>)"
207 |   endfor
208 | endfor
209 | 


--------------------------------------------------------------------------------