Full Code of tpope/vim-pathogen for AI

Repository: tpope/vim-pathogen
Branch: master
Commit: ac4dd9494fa9
Files: 5
Total size: 19.9 KB

Directory structure:
gitextract_e6ho_zib/

├── .github/
│   └── FUNDING.yml
├── CONTRIBUTING.markdown
├── LICENSE
├── README.markdown
└── autoload/
    └── pathogen.vim

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/FUNDING.yml
================================================
github: tpope
custom: ["https://www.paypal.me/vimpope"]


================================================
FILE: CONTRIBUTING.markdown
================================================
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.


================================================
FILE: LICENSE
================================================
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.


================================================
FILE: README.markdown
================================================
# 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`.


================================================
FILE: autoload/pathogen.vim
================================================
" 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: