]> git.madduck.net Git - etc/vim.git/commitdiff

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Squashed '.vim/bundle/vim-pathogen/' content from commit ac4dd949
authormartin f. krafft <madduck@madduck.net>
Tue, 8 Apr 2025 14:50:09 +0000 (16:50 +0200)
committermartin f. krafft <madduck@madduck.net>
Tue, 8 Apr 2025 14:50:09 +0000 (16:50 +0200)
git-subtree-dir: .vim/bundle/vim-pathogen
git-subtree-split: ac4dd9494fa9008754e49dff85bff1b5746c89b4

.github/FUNDING.yml [new file with mode: 0644]
CONTRIBUTING.markdown [new file with mode: 0644]
LICENSE [new file with mode: 0644]
README.markdown [new file with mode: 0644]
autoload/pathogen.vim [new file with mode: 0644]

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644 (file)
index 0000000..e2a49d1
--- /dev/null
@@ -0,0 +1,2 @@
+github: tpope
+custom: ["https://www.paypal.me/vimpope"]
diff --git a/CONTRIBUTING.markdown b/CONTRIBUTING.markdown
new file mode 100644 (file)
index 0000000..3bbabf8
--- /dev/null
@@ -0,0 +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 --git a/LICENSE b/LICENSE
new file mode 100644 (file)
index 0000000..99f03ca
--- /dev/null
+++ b/LICENSE
@@ -0,0 +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 --git a/README.markdown b/README.markdown
new file mode 100644 (file)
index 0000000..8dc6a87
--- /dev/null
@@ -0,0 +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 --git a/autoload/pathogen.vim b/autoload/pathogen.vim
new file mode 100644 (file)
index 0000000..8cd8e97
--- /dev/null
@@ -0,0 +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: