Refactor global variables into autoload variables.

All global variables that are not part of the public API (mentioned in the
documentation) are turned into autoload variables.  This is intended to give
all global variables defined by Vundle.vim a common prefix.  The variable
g:default_git_proto is part of the public API and is therefor not changed.
This is the only exception.

Changed:
   g:bundle_dir            -> vundle#bundle_dir
   g:bundles               -> vundle#bundles
   g:updated_bundles       -> vundle#updated_bundles
   g:vundle_lazy_load      -> vundle#lazy_load
   g:vundle_log            -> vundle#log
Unchanged:
   g:default_git_proto

autoload/vundle.vim

@@ -21,7 +21,7 @@ com! -nargs=? -bang   PluginClean
 \ call vundle#installer#clean('!' == '<bang>')
 
 com! -nargs=0         PluginDocs
-\ call vundle#installer#helptags(g:bundles)
+\ call vundle#installer#helptags(g:vundle#bundles)
 
 " Aliases
 com! -nargs=* -complete=custom,vundle#scripts#complete PluginUpdate PluginInstall! <args>
@@ -61,22 +61,22 @@ endif
 " :Plugin command in the vimrc.  It is not possible to do this automatically
 " because when loading the vimrc file no plugins where loaded yet.
 func! vundle#rc(...) abort
-  let g:bundle_dir = len(a:000) > 0 ? expand(a:1, 1) : expand('$HOME/.vim/bundle', 1)
-  let g:updated_bundles = []
-  let g:vundle_log = []
+  let g:vundle#bundle_dir = len(a:000) > 0 ? expand(a:1, 1) : expand('$HOME/.vim/bundle', 1)
+  let g:vundle#updated_bundles = []
+  let g:vundle#log = []
   call vundle#config#init()
 endf
 
 " Alternative to vundle#rc, offers speed up by modifying rtp only when end()
 " called later.
 func! vundle#begin(...) abort
-  let g:vundle_lazy_load = 1
+  let g:vundle#lazy_load = 1
   call call('vundle#rc', a:000)
 endf
 
 " Finishes putting plugins on the rtp.
 func! vundle#end(...) abort
-  unlet g:vundle_lazy_load
+  unlet g:vundle#lazy_load
   call vundle#config#activate_bundles()
 endf
 

autoload/vundle/config.vim

@@ -10,11 +10,11 @@ func! vundle#config#bundle(arg, ...)
   if !s:check_bundle_name(bundle)
     return
   endif
-  if exists('g:vundle_lazy_load') && g:vundle_lazy_load
-    call add(g:bundles, bundle)
+  if exists('g:vundle#lazy_load') && g:vundle#lazy_load
+    call add(g:vundle#bundles, bundle)
   else
     call s:rtp_rm_a()
-    call add(g:bundles, bundle)
+    call add(g:vundle#bundles, bundle)
     call s:rtp_add_a()
     call s:rtp_add_defaults()
   endif
@@ -40,9 +40,9 @@ endf
 " once.
 " ---------------------------------------------------------------------------
 func! vundle#config#init()
-  if !exists('g:bundles') | let g:bundles = [] | endif
+  if !exists('g:vundle#bundles') | let g:vundle#bundles = [] | endif
   call s:rtp_rm_a()
-  let g:bundles = []
+  let g:vundle#bundles = []
   let s:bundle_names = {}
 endf
 
@@ -55,11 +55,11 @@ endf
 func! vundle#config#require(bundles) abort
   for b in a:bundles
     call s:rtp_add(b.rtpath)
-    call s:rtp_add(g:bundle_dir)
+    call s:rtp_add(g:vundle#bundle_dir)
     " TODO: it has to be relative rtpath, not bundle.name
     exec 'runtime! '.b.name.'/plugin/*.vim'
     exec 'runtime! '.b.name.'/after/*.vim'
-    call s:rtp_rm(g:bundle_dir)
+    call s:rtp_rm(g:vundle#bundle_dir)
   endfor
   call s:rtp_add_defaults()
 endf
@@ -180,7 +180,7 @@ endf
 " runtimepath.
 " ---------------------------------------------------------------------------
 func! s:rtp_rm_a()
-  let paths = map(copy(g:bundles), 'v:val.rtpath')
+  let paths = map(copy(g:vundle#bundles), 'v:val.rtpath')
   let prepends = join(paths, ',')
   let appends = join(paths, '/after,').'/after'
   exec 'set rtp-='.fnameescape(prepends)
@@ -193,7 +193,7 @@ endf
 " runtimepath.
 " ---------------------------------------------------------------------------
 func! s:rtp_add_a()
-  let paths = map(copy(g:bundles), 'v:val.rtpath')
+  let paths = map(copy(g:vundle#bundles), 'v:val.rtpath')
   let prepends = join(paths, ',')
   let appends = join(paths, '/after,').'/after'
   exec 'set rtp^='.fnameescape(prepends)
@@ -262,7 +262,7 @@ let s:bundle = {}
 " return -- the target location to clone this bundle to
 " ---------------------------------------------------------------------------
 func! s:bundle.path()
-  return s:expand_path(g:bundle_dir.'/'.self.name)
+  return s:expand_path(g:vundle#bundle_dir.'/'.self.name)
 endf
 
 

autoload/vundle/installer.vim

@@ -1,17 +1,18 @@
 " ---------------------------------------------------------------------------
-" Try to clone all new bundles given (or all bundles in g:bundles by default)
-" to g:bundle_dir.  If a:bang is 1 it will also update all plugins (git pull).
+" Try to clone all new bundles given (or all bundles in g:vundle#bundles by
+" default) to g:vundle#bundle_dir.  If a:bang is 1 it will also update all
+" plugins (git pull).
 "
 " bang   -- 1 or 0
 " ...    -- any number of bundle specifications (separate arguments)
 " ---------------------------------------------------------------------------
 func! vundle#installer#new(bang, ...) abort
   " No specific plugins are specified. Operate on all plugins.
   if a:0 == 0
-    let bundles = g:bundles
+    let bundles = g:vundle#bundles
   " Specific plugins are specified for update. Update them.
   elseif (a:bang)
-    let bundles = filter(copy(g:bundles), 'index(a:000, v:val.name) > -1')
+    let bundles = filter(copy(g:vundle#bundles), 'index(a:000, v:val.name) > -1')
   " Specific plugins are specified for installation. Install them.
   else
     let bundles = map(copy(a:000), 'vundle#config#bundle(v:val, {})')
@@ -23,7 +24,7 @@ func! vundle#installer#new(bang, ...) abort
   endif
 
   let names = vundle#scripts#bundle_names(map(copy(bundles), 'v:val.name_spec'))
-  call vundle#scripts#view('Installer',['" Installing plugins to '.expand(g:bundle_dir, 1)], names +  ['Helptags'])
+  call vundle#scripts#view('Installer',['" Installing plugins to '.expand(g:vundle#bundle_dir, 1)], names +  ['Helptags'])
 
   " This calls 'add' as a normal mode command. This is a buffer local mapping
   " defined in vundle#scripts#view(). The mapping will call a buffer local
@@ -163,10 +164,10 @@ endf
 " return -- the return value from s:sync()
 " ---------------------------------------------------------------------------
 func! vundle#installer#install(bang, name) abort
-  if !isdirectory(g:bundle_dir) | call mkdir(g:bundle_dir, 'p') | endif
+  if !isdirectory(g:vundle#bundle_dir) | call mkdir(g:vundle#bundle_dir, 'p') | endif
 
   let n = substitute(a:name,"['".'"]\+','','g')
-  let matched = filter(copy(g:bundles), 'v:val.name_spec == n')
+  let matched = filter(copy(g:vundle#bundles), 'v:val.name_spec == n')
 
   if len(matched) > 0
     let b = matched[0]
@@ -179,12 +180,12 @@ endf
 
 
 " ---------------------------------------------------------------------------
-" Call :helptags for all bundles in g:bundles.
+" Call :helptags for all bundles in g:vundle#bundles.
 "
 " return -- 'error' if an error occurred, else return 'helptags'
 " ---------------------------------------------------------------------------
 func! vundle#installer#docs() abort
-  let error_count = vundle#installer#helptags(g:bundles)
+  let error_count = vundle#installer#helptags(g:vundle#bundles)
   if error_count > 0
       return 'error'
   endif
@@ -222,10 +223,10 @@ endf
 " bang   -- not used
 " ---------------------------------------------------------------------------
 func! vundle#installer#list(bang) abort
-  let bundles = vundle#scripts#bundle_names(map(copy(g:bundles), 'v:val.name_spec'))
+  let bundles = vundle#scripts#bundle_names(map(copy(g:vundle#bundles), 'v:val.name_spec'))
   call vundle#scripts#view('list', ['" My Plugins'], bundles)
   redraw
-  echo len(g:bundles).' plugins configured'
+  echo len(g:vundle#bundles).' plugins configured'
 endf
 
 
@@ -237,10 +238,10 @@ endf
 "           should be removed unconditionally
 " ---------------------------------------------------------------------------
 func! vundle#installer#clean(bang) abort
-  let bundle_dirs = map(copy(g:bundles), 'v:val.path()')
+  let bundle_dirs = map(copy(g:vundle#bundles), 'v:val.path()')
   let all_dirs = (v:version > 702 || (v:version == 702 && has("patch51")))
-  \   ? split(globpath(g:bundle_dir, '*', 1), "\n")
-  \   : split(globpath(g:bundle_dir, '*'), "\n")
+  \   ? split(globpath(g:vundle#bundle_dir, '*', 1), "\n")
+  \   : split(globpath(g:vundle#bundle_dir, '*'), "\n")
   let x_dirs = filter(all_dirs, '0 > index(bundle_dirs, v:val)')
 
   if empty(x_dirs)
@@ -465,7 +466,7 @@ func! s:sync(bang, bundle) abort
     return 'todate'
   endif
 
-  call add(g:updated_bundles, [initial_sha, updated_sha, a:bundle])
+  call add(g:vundle#updated_bundles, [initial_sha, updated_sha, a:bundle])
   return 'updated'
 endf
 
@@ -527,7 +528,7 @@ func! s:log(str, ...) abort
   let lines = split(a:str, '\n', 1)
   let time = strftime(fmt)
   for line in lines
-      call add(g:vundle_log, '['. time .'] '. prefix . line)
+      call add(g:vundle#log, '['. time .'] '. prefix . line)
   endfor
   return a:str
 endf

autoload/vundle/scripts.vim

@@ -42,7 +42,7 @@ endf
 func! vundle#scripts#complete(a,c,d)
   if match(a:c, '\v^%(Plugin|Vundle)%(Install!|Update)') == 0
     " Only installed plugins if updating
-    return join(map(copy(g:bundles), 'v:val.name'), "\n")
+    return join(map(copy(g:vundle#bundles), 'v:val.name'), "\n")
   else
     " Or all known plugins otherwise
     return join(s:load_scripts(0),"\n")
@@ -61,7 +61,7 @@ func! s:view_log()
   if bufloaded(s:log_file)
     execute 'silent bdelete' s:log_file
   endif
-  call writefile(g:vundle_log, s:log_file)
+  call writefile(g:vundle#log, s:log_file)
   execute 'silent pedit ' . s:log_file
 
   wincmd P | wincmd H
@@ -74,7 +74,7 @@ endf
 " ---------------------------------------------------------------------------
 func! s:create_changelog() abort
   let changelog = ['Updated Plugins:']
-  for bundle_data in g:updated_bundles
+  for bundle_data in g:vundle#updated_bundles
     let initial_sha = bundle_data[0]
     let updated_sha = bundle_data[1]
     let bundle      = bundle_data[2]
@@ -258,7 +258,7 @@ endf
 "           specifications) of all plugins from vim-scripts.org
 " ---------------------------------------------------------------------------
 func! s:load_scripts(bang)
-  let f = expand(g:bundle_dir.'/.vundle/script-names.vim-scripts.org.json', 1)
+  let f = expand(g:vundle#bundle_dir.'/.vundle/script-names.vim-scripts.org.json', 1)
   if a:bang || !filereadable(f)
     if 0 != s:fetch_scripts(f)
       return []