From: martin f. krafft <madduck@madduck.net>
Date: Tue, 8 Apr 2025 14:50:09 +0000 (+0200)
Subject: Merge commit '55bf04470ecc026e71c037f0f35402fdeac66767' as '.vim/bundle/vim-pathogen'
X-Git-Url: https://git.madduck.net/etc/vim.git/commitdiff_plain/9762221d9cf8455ddbd79c1f3c3580c2934ec800?hp=-c

Merge commit '55bf04470ecc026e71c037f0f35402fdeac66767' as '.vim/bundle/vim-pathogen'
---

9762221d9cf8455ddbd79c1f3c3580c2934ec800
diff --combined .vim/bundle/vim-pathogen/.github/FUNDING.yml
index 00000000,e2a49d11..e2a49d11
mode 000000,100644..100644
--- a/.vim/bundle/vim-pathogen/.github/FUNDING.yml
+++ b/.vim/bundle/vim-pathogen/.github/FUNDING.yml
@@@ -1,0 -1,2 +1,2 @@@
+ github: tpope
+ custom: ["https://www.paypal.me/vimpope"]
diff --combined .vim/bundle/vim-pathogen/CONTRIBUTING.markdown
index 00000000,3bbabf8d..3bbabf8d
mode 000000,100644..100644
--- a/.vim/bundle/vim-pathogen/CONTRIBUTING.markdown
+++ b/.vim/bundle/vim-pathogen/CONTRIBUTING.markdown
@@@ -1,0 -1,18 +1,18 @@@
+ Follow the commit message guidelines at [commit.style](https://commit.style).
+ This is an absolute requirement for my repositories, and doing so proves you
+ actually read the contribution guidelines, which makes for a good first
+ impression.
+ 
+ Good commit messages imply good commits.  Pull requests should typically be a
+ single commit, or for the rare complicated case, a series of atomic commits.
+ If I request a change, use `git commit --amend` or `git rebase --interactive`
+ and force push to your branch.
+ 
+ For feature requests, don't be shy about proposing it in an issue before
+ drafting a patch.  If it's a great idea, I might do it for you.  If it's a
+ terrible idea, no patch will change my mind.
+ 
+ The worst ideas are configuration options.  You'll need to provide a great
+ justification in order to persuade me to take on the maintenance and support
+ burden it will inevitably entail.  See if you can get away with a custom map
+ or autocommand instead.
diff --combined .vim/bundle/vim-pathogen/LICENSE
index 00000000,99f03caf..99f03caf
mode 000000,100644..100644
--- a/.vim/bundle/vim-pathogen/LICENSE
+++ b/.vim/bundle/vim-pathogen/LICENSE
@@@ -1,0 -1,81 +1,81 @@@
+ VIM LICENSE
+ 
+ I)  There are no restrictions on distributing unmodified copies of
+     pathogen.vim except that they must include this license text.  You can
+     also distribute unmodified parts of pathogen.vim, likewise unrestricted
+     except that they must include this license text.  You are also allowed to
+     include executables that you made from the unmodified pathogen.vim
+     sources, plus your own usage examples and Vim scripts.
+ 
+ II) It is allowed to distribute a modified (or extended) version of
+     pathogen.vim, including executables and/or source code, when the following
+     four conditions are met:
+     1) This license text must be included unmodified.
+     2) The modified pathogen.vim must be distributed in one of the following
+        five ways:
+        a) If you make changes to pathogen.vim yourself, you must clearly
+           describe in the distribution how to contact you.  When the
+           maintainer asks you (in any way) for a copy of the modified
+           pathogen.vim you distributed, you must make your changes, including
+           source code, available to the maintainer without fee.  The
+           maintainer reserves the right to include your changes in the
+           official version of pathogen.vim.  What the maintainer will do with
+           your changes and under what license they will be distributed is
+           negotiable.  If there has been no negotiation then this license, or
+           a later version, also applies to your changes. The current
+           maintainer is Bram Moolenaar <Bram@vim.org>.  If this changes it
+           will be announced in appropriate places (most likely vim.sf.net,
+           www.vim.org and/or comp.editors). When it is completely impossible
+           to contact the maintainer, the obligation to send him your changes
+           ceases.  Once the maintainer has confirmed that he has received your
+           changes they will not have to be sent again.
+        b) If you have received a modified pathogen.vim that was distributed as
+           mentioned under a) you are allowed to further distribute it
+           unmodified, as mentioned at I).  If you make additional changes the
+           text under a) applies to those changes.
+        c) Provide all the changes, including source code, with every copy of
+           the modified pathogen.vim you distribute.  This may be done in the
+           form of a context diff.  You can choose what license to use for new
+           code you add.  The changes and their license must not restrict
+           others from making their own changes to the official version of
+           pathogen.vim.
+        d) When you have a modified pathogen.vim which includes changes as
+           mentioned under c), you can distribute it without the source code
+           for the changes if the following three conditions are met:
+           - The license that applies to the changes permits you to distribute
+             the changes to the Vim maintainer without fee or restriction, and
+             permits the Vim maintainer to include the changes in the official
+             version of pathogen.vim without fee or restriction.
+           - You keep the changes for at least three years after last
+             distributing the corresponding modified pathogen.vim.  When the
+             maintainer or someone who you distributed the modified
+             pathogen.vim to asks you (in any way) for the changes within this
+             period, you must make them available to him.
+           - You clearly describe in the distribution how to contact you.  This
+             contact information must remain valid for at least three years
+             after last distributing the corresponding modified pathogen.vim,
+             or as long as possible.
+        e) When the GNU General Public License (GPL) applies to the changes,
+           you can distribute the modified pathogen.vim under the GNU GPL
+           version 2 or any later version.
+     3) A message must be added, at least in the output of the ":version"
+        command and in the intro screen, such that the user of the modified
+        pathogen.vim is able to see that it was modified.  When distributing as
+        mentioned under 2)e) adding the message is only required for as far as
+        this does not conflict with the license used for the changes.
+     4) The contact information as required under 2)a) and 2)d) must not be
+        removed or changed, except that the person himself can make
+        corrections.
+ 
+ III) If you distribute a modified version of pathogen.vim, you are encouraged
+      to use the Vim license for your changes and make them available to the
+      maintainer, including the source code.  The preferred way to do this is
+      by e-mail or by uploading the files to a server and e-mailing the URL. If
+      the number of changes is small (e.g., a modified Makefile) e-mailing a
+      context diff will do.  The e-mail address to be used is
+      <maintainer@vim.org>
+ 
+ IV)  It is not allowed to remove this license from the distribution of the
+      pathogen.vim sources, parts of it or from a modified version.  You may
+      use this license for previous pathogen.vim releases instead of the
+      license that they came with, at your option.
diff --combined .vim/bundle/vim-pathogen/README.markdown
index 00000000,8dc6a87a..8dc6a87a
mode 000000,100644..100644
--- a/.vim/bundle/vim-pathogen/README.markdown
+++ b/.vim/bundle/vim-pathogen/README.markdown
@@@ -1,0 -1,153 +1,153 @@@
+ # pathogen.vim
+ 
+ Manage your `'runtimepath'` with ease.  In practical terms, pathogen.vim
+ makes it super easy to install plugins and runtime files in their own
+ private directories.
+ 
+ **For new users, I recommend using Vim's built-in package management
+ instead.**  `:help packages`
+ 
+ ## Installation
+ 
+ Install to `~/.vim/autoload/pathogen.vim`.
+ Or copy and paste the following into your terminal/shell:
+ 
+     mkdir -p ~/.vim/autoload ~/.vim/bundle && \
+     curl -LSso ~/.vim/autoload/pathogen.vim https://tpo.pe/pathogen.vim
+ 
+ If you're using Windows, change all occurrences of `~/.vim` to `~\vimfiles`.
+ 
+ ## Runtime Path Manipulation
+ 
+ Add this to your vimrc:
+ 
+     execute pathogen#infect()
+ 
+ If you're brand new to Vim and lacking a vimrc, `vim ~/.vimrc` and paste
+ in the following super-minimal example:
+ 
+     execute pathogen#infect()
+     syntax on
+     filetype plugin indent on
+ 
+ Now any plugins you wish to install can be extracted to a subdirectory
+ under `~/.vim/bundle`, and they will be added to the `'runtimepath'`.
+ Observe:
+ 
+     cd ~/.vim/bundle && \
+     git clone https://github.com/tpope/vim-sensible.git
+ 
+ Now [sensible.vim](https://github.com/tpope/vim-sensible) is installed.
+ If you really want to get crazy, you could set it up as a submodule in
+ whatever repository you keep your dot files in.  I don't like to get
+ crazy.
+ 
+ If you don't like the directory name `bundle`, you can pass a runtime relative
+ glob as an argument:
+ 
+     execute pathogen#infect('stuff/{}')
+ 
+ The `{}` indicates where the expansion should occur.
+ 
+ You can also pass an absolute path instead.  I keep the plugins I maintain under `~/src`, and this is how I add them:
+ 
+     execute pathogen#infect('bundle/{}', '~/src/vim/bundle/{}')
+ 
+ Normally to generate documentation, Vim expects you to run `:helptags`
+ on each directory with documentation (e.g., `:helptags ~/.vim/doc`).
+ Provided with pathogen.vim is a `:Helptags` command that does this on
+ every directory in your `'runtimepath'`.  If you really want to get
+ crazy, you could even invoke `Helptags` in your vimrc.  I don't like to
+ get crazy.
+ 
+ Finally, pathogen.vim has a rich API that can manipulate `'runtimepath'`
+ and other comma-delimited path options in ways most people will never
+ need to do.  If you're one of those edge cases, look at the source.
+ It's well documented.
+ 
+ ## Native Vim Package Management
+ 
+ Vim 8 includes support for package management in a manner similar to
+ pathogen.vim.  If you'd like to transition to this native support,
+ pathogen.vim can help.  Calling `pathogen#infect()` on an older version of Vim
+ will supplement the `bundle/{}` default with `pack/{}/start/{}`, effectively
+ backporting a subset of the new native functionality.
+ 
+ ## Runtime File Editing
+ 
+ `:Vopen`, `:Vedit`, `:Vsplit`, `:Vvsplit`, `:Vtabedit`, `:Vpedit`, and
+ `:Vread` have all moved to [scriptease.vim][].
+ 
+ [scriptease.vim]: https://github.com/tpope/vim-scriptease
+ 
+ ## FAQ
+ 
+ > Can I put pathogen.vim in a submodule like all my other plugins?
+ 
+ Sure, stick it under `~/.vim/bundle`, and prepend the following to your
+ vimrc:
+ 
+     runtime bundle/vim-pathogen/autoload/pathogen.vim
+ 
+ Or if your bundles are somewhere other than `~/.vim` (say, `~/src/vim`):
+ 
+     source ~/src/vim/bundle/vim-pathogen/autoload/pathogen.vim
+ 
+ > Will you accept these 14 pull requests adding a `.gitignore` for
+ > `tags` so I don't see untracked changes in my dot files repository?
+ 
+ No, but I'll teach you how to ignore `tags` globally:
+ 
+     git config --global core.excludesfile '~/.cvsignore'
+     echo tags >> ~/.cvsignore
+ 
+ While any filename will work, I've chosen to follow the ancient
+ tradition of `.cvsignore` because utilities like rsync use it, too.
+ Clever, huh?
+ 
+ > What about Vimballs?
+ 
+ If you really must use one:
+ 
+     :e name.vba
+     :!mkdir ~/.vim/bundle/name
+     :UseVimball ~/.vim/bundle/name
+ 
+ > Why don't my plugins load when I use Vim sessions?
+ 
+ Vim sessions default to capturing all global options, which includes the
+ `'runtimepath'` that pathogen.vim manipulates.  This can cause other problems
+ too, so I recommend turning that behavior off:
+ 
+     set sessionoptions-=options
+ 
+ ## Contributing
+ 
+ If your [commit message sucks](http://stopwritingramblingcommitmessages.com/),
+ I'm not going to accept your pull request.  I've explained very politely
+ dozens of times that
+ [my general guidelines](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+ are absolute rules on my own repositories, so I may lack the energy to
+ explain it to you yet another time.  And please, if I ask you to change
+ something, `git commit --amend`.
+ 
+ Beyond that, don't be shy about asking before patching.  What takes you
+ hours might take me minutes simply because I have both domain knowledge
+ and a perverse knowledge of Vim script so vast that many would consider
+ it a symptom of mental illness.  On the flip side, some ideas I'll
+ reject no matter how good the implementation is.  "Send a patch" is an
+ edge case answer in my book.
+ 
+ ## Self-Promotion
+ 
+ Like pathogen.vim?  Follow the repository on
+ [GitHub](https://github.com/tpope/vim-pathogen) and vote for it on
+ [vim.org](http://www.vim.org/scripts/script.php?script_id=2332).  And if
+ you're feeling especially charitable, follow [tpope](http://tpo.pe/) on
+ [Twitter](http://twitter.com/tpope) and
+ [GitHub](https://github.com/tpope).
+ 
+ ## License
+ 
+ Copyright (c) Tim Pope.  Distributed under the same terms as Vim itself.
+ See `:help license`.
diff --combined .vim/bundle/vim-pathogen/autoload/pathogen.vim
index 00000000,8cd8e97b..8cd8e97b
mode 000000,100644..100644
--- a/.vim/bundle/vim-pathogen/autoload/pathogen.vim
+++ b/.vim/bundle/vim-pathogen/autoload/pathogen.vim
@@@ -1,0 -1,264 +1,264 @@@
+ " pathogen.vim - path option manipulation
+ " Maintainer:   Tim Pope <http://tpo.pe/>
+ " Version:      2.4
+ 
+ " Install in ~/.vim/autoload (or ~\vimfiles\autoload).
+ "
+ " For management of individually installed plugins in ~/.vim/bundle (or
+ " ~\vimfiles\bundle), adding `execute pathogen#infect()` to the top of your
+ " .vimrc is the only other setup necessary.
+ "
+ " The API is documented inline below.
+ 
+ if exists("g:loaded_pathogen") || &cp
+   finish
+ endif
+ let g:loaded_pathogen = 1
+ 
+ " Point of entry for basic default usage.  Give a relative path to invoke
+ " pathogen#interpose() or an absolute path to invoke pathogen#surround().
+ " Curly braces are expanded with pathogen#expand(): "bundle/{}" finds all
+ " subdirectories inside "bundle" inside all directories in the runtime path.
+ " If no arguments are given, defaults "bundle/{}", and also "pack/{}/start/{}"
+ " on versions of Vim without native package support.
+ function! pathogen#infect(...) abort
+   if a:0
+     let paths = filter(reverse(copy(a:000)), 'type(v:val) == type("")')
+   else
+     let paths = ['bundle/{}', 'pack/{}/start/{}']
+   endif
+   if has('packages')
+     call filter(paths, 'v:val !~# "^pack/[^/]*/start/[^/]*$"')
+   endif
+   let static = '^\%([$~\\/]\|\w:[\\/]\)[^{}*]*$'
+   for path in filter(copy(paths), 'v:val =~# static')
+     call pathogen#surround(path)
+   endfor
+   for path in filter(copy(paths), 'v:val !~# static')
+     if path =~# '^\%([$~\\/]\|\w:[\\/]\)'
+       call pathogen#surround(path)
+     else
+       call pathogen#interpose(path)
+     endif
+   endfor
+   call pathogen#cycle_filetype()
+   if pathogen#is_disabled($MYVIMRC)
+     return 'finish'
+   endif
+   return ''
+ endfunction
+ 
+ " Split a path into a list.
+ function! pathogen#split(path) abort
+   if type(a:path) == type([]) | return a:path | endif
+   if empty(a:path) | return [] | endif
+   let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
+   return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
+ endfunction
+ 
+ " Convert a list to a path.
+ function! pathogen#join(...) abort
+   if type(a:1) == type(1) && a:1
+     let i = 1
+     let space = ' '
+   else
+     let i = 0
+     let space = ''
+   endif
+   let path = ""
+   while i < a:0
+     if type(a:000[i]) == type([])
+       let list = a:000[i]
+       let j = 0
+       while j < len(list)
+         let escaped = substitute(list[j],'[,'.space.']\|\\[\,'.space.']\@=','\\&','g')
+         let path .= ',' . escaped
+         let j += 1
+       endwhile
+     else
+       let path .= "," . a:000[i]
+     endif
+     let i += 1
+   endwhile
+   return substitute(path,'^,','','')
+ endfunction
+ 
+ " Convert a list to a path with escaped spaces for 'path', 'tag', etc.
+ function! pathogen#legacyjoin(...) abort
+   return call('pathogen#join',[1] + a:000)
+ endfunction
+ 
+ " Turn filetype detection off and back on again if it was already enabled.
+ function! pathogen#cycle_filetype() abort
+   if exists('g:did_load_filetypes')
+     filetype off
+     filetype on
+   endif
+ endfunction
+ 
+ " Check if a bundle is disabled.  A bundle is considered disabled if its
+ " basename or full name is included in the list g:pathogen_blacklist or the
+ " comma delimited environment variable $VIMBLACKLIST.
+ function! pathogen#is_disabled(path) abort
+   if a:path =~# '\~$'
+     return 1
+   endif
+   let sep = pathogen#slash()
+   let blacklist = get(g:, 'pathogen_blacklist', get(g:, 'pathogen_disabled', [])) + pathogen#split($VIMBLACKLIST)
+   if !empty(blacklist)
+     call map(blacklist, 'substitute(v:val, "[\\/]$", "", "")')
+   endif
+   return index(blacklist, fnamemodify(a:path, ':t')) != -1 || index(blacklist, a:path) != -1
+ endfunction
+ 
+ " Prepend the given directory to the runtime path and append its corresponding
+ " after directory.  Curly braces are expanded with pathogen#expand().
+ function! pathogen#surround(path) abort
+   let sep = pathogen#slash()
+   let rtp = pathogen#split(&rtp)
+   let path = fnamemodify(a:path, ':s?[\\/]\=$??')
+   let before = filter(pathogen#expand(path), '!pathogen#is_disabled(v:val)')
+   let after = filter(reverse(pathogen#expand(path, sep.'after')), '!pathogen#is_disabled(v:val[0 : -7])')
+   call filter(rtp, 'index(before + after, v:val) == -1')
+   let &rtp = pathogen#join(before, rtp, after)
+   return &rtp
+ endfunction
+ 
+ " For each directory in the runtime path, add a second entry with the given
+ " argument appended.  Curly braces are expanded with pathogen#expand().
+ function! pathogen#interpose(name) abort
+   let sep = pathogen#slash()
+   let name = a:name
+   if has_key(s:done_bundles, name)
+     return ""
+   endif
+   let s:done_bundles[name] = 1
+   let list = []
+   for dir in pathogen#split(&rtp)
+     if dir =~# '\<after$'
+       let list += reverse(filter(pathogen#expand(dir[0 : -6].name, sep.'after'), '!pathogen#is_disabled(v:val[0 : -7])')) + [dir]
+     else
+       let list += [dir] + filter(pathogen#expand(dir.sep.name), '!pathogen#is_disabled(v:val)')
+     endif
+   endfor
+   let &rtp = pathogen#join(pathogen#uniq(list))
+   return 1
+ endfunction
+ 
+ let s:done_bundles = {}
+ 
+ " Invoke :helptags on all non-$VIM doc directories in runtimepath.
+ function! pathogen#helptags() abort
+   let sep = pathogen#slash()
+   for glob in pathogen#split(&rtp)
+     for dir in map(split(glob(glob), "\n"), 'v:val.sep."/doc/".sep')
+       if (dir)[0 : strlen($VIMRUNTIME)] !=# $VIMRUNTIME.sep && filewritable(dir) == 2 && !empty(split(glob(dir.'*.txt'))) && (!filereadable(dir.'tags') || filewritable(dir.'tags'))
+         silent! execute 'helptags' pathogen#fnameescape(dir)
+       endif
+     endfor
+   endfor
+ endfunction
+ 
+ command! -bar Helptags :call pathogen#helptags()
+ 
+ " Execute the given command.  This is basically a backdoor for --remote-expr.
+ function! pathogen#execute(...) abort
+   for command in a:000
+     execute command
+   endfor
+   return ''
+ endfunction
+ 
+ " Section: Unofficial
+ 
+ function! pathogen#is_absolute(path) abort
+   return a:path =~# (has('win32') ? '^\%([\\/]\|\w:\)[\\/]\|^[~$]' : '^[/~$]')
+ endfunction
+ 
+ " Given a string, returns all possible permutations of comma delimited braced
+ " alternatives of that string.  pathogen#expand('/{a,b}/{c,d}') yields
+ " ['/a/c', '/a/d', '/b/c', '/b/d'].  Empty braces are treated as a wildcard
+ " and globbed.  Actual globs are preserved.
+ function! pathogen#expand(pattern, ...) abort
+   let after = a:0 ? a:1 : ''
+   let pattern = substitute(a:pattern, '^[~$][^\/]*', '\=expand(submatch(0))', '')
+   if pattern =~# '{[^{}]\+}'
+     let [pre, pat, post] = split(substitute(pattern, '\(.\{-\}\){\([^{}]\+\)}\(.*\)', "\\1\001\\2\001\\3", ''), "\001", 1)
+     let found = map(split(pat, ',', 1), 'pre.v:val.post')
+     let results = []
+     for pattern in found
+       call extend(results, pathogen#expand(pattern))
+     endfor
+   elseif pattern =~# '{}'
+     let pat = matchstr(pattern, '^.*{}[^*]*\%($\|[\\/]\)')
+     let post = pattern[strlen(pat) : -1]
+     let results = map(split(glob(substitute(pat, '{}', '*', 'g')), "\n"), 'v:val.post')
+   else
+     let results = [pattern]
+   endif
+   let vf = pathogen#slash() . 'vimfiles'
+   call map(results, 'v:val =~# "\\*" ? v:val.after : isdirectory(v:val.vf.after) ? v:val.vf.after : isdirectory(v:val.after) ? v:val.after : ""')
+   return filter(results, '!empty(v:val)')
+ endfunction
+ 
+ " \ on Windows unless shellslash is set, / everywhere else.
+ function! pathogen#slash() abort
+   return !exists("+shellslash") || &shellslash ? '/' : '\'
+ endfunction
+ 
+ function! pathogen#separator() abort
+   return pathogen#slash()
+ endfunction
+ 
+ " Convenience wrapper around glob() which returns a list.
+ function! pathogen#glob(pattern) abort
+   let files = split(glob(a:pattern),"\n")
+   return map(files,'substitute(v:val,"[".pathogen#slash()."/]$","","")')
+ endfunction
+ 
+ " Like pathogen#glob(), only limit the results to directories.
+ function! pathogen#glob_directories(pattern) abort
+   return filter(pathogen#glob(a:pattern),'isdirectory(v:val)')
+ endfunction
+ 
+ " Remove duplicates from a list.
+ function! pathogen#uniq(list) abort
+   let i = 0
+   let seen = {}
+   while i < len(a:list)
+     if (a:list[i] ==# '' && exists('empty')) || has_key(seen,a:list[i])
+       call remove(a:list,i)
+     elseif a:list[i] ==# ''
+       let i += 1
+       let empty = 1
+     else
+       let seen[a:list[i]] = 1
+       let i += 1
+     endif
+   endwhile
+   return a:list
+ endfunction
+ 
+ " Backport of fnameescape().
+ function! pathogen#fnameescape(string) abort
+   if exists('*fnameescape')
+     return fnameescape(a:string)
+   elseif a:string ==# '-'
+     return '\-'
+   else
+     return substitute(escape(a:string," \t\n*?[{`$\\%#'\"|!<"),'^[+>]','\\&','')
+   endif
+ endfunction
+ 
+ " Like findfile(), but hardcoded to use the runtimepath.
+ function! pathogen#runtime_findfile(file,count) abort
+   let rtp = pathogen#join(1,pathogen#split(&rtp))
+   let file = findfile(a:file,rtp,a:count)
+   if file ==# ''
+     return ''
+   else
+     return fnamemodify(file,':p')
+   endif
+ endfunction
+ 
+ " vim:set et sw=2: