diff --git a/autoload/vundle/config.vim b/autoload/vundle/config.vim
index 4292095..309fb4e 100644
--- a/autoload/vundle/config.vim
+++ b/autoload/vundle/config.vim
@@ -1,8 +1,10 @@
+" ---------------------------------------------------------------------------
 " Add a plugin to the runtimepath.
 "
 " arg    -- a string specifying the plugin
 " ...    -- a dictionary of options for the plugin
 " return -- the return value from vundle#config#init_bundle()
+" ---------------------------------------------------------------------------
 func! vundle#config#bundle(arg, ...)
   let bundle = vundle#config#init_bundle(a:arg, a:000)
   if exists('g:vundle_lazy_load') && g:vundle_lazy_load
@@ -16,24 +18,36 @@ func! vundle#config#bundle(arg, ...)
   return bundle
 endf
 
+
+" ---------------------------------------------------------------------------
+"  When lazy bundle load is used (begin/end functions), add all configured
+"  bundles to runtimepath and reorder appropriately.
+" ---------------------------------------------------------------------------
 func! vundle#config#activate_bundles()
   call s:rtp_add_a()
   call s:rtp_add_defaults()
 endf
 
+
+" ---------------------------------------------------------------------------
 " Initialize Vundle.
 "
-" return -- 0 (unconditionally)
+" Start a new bundles list and make sure the runtimepath does not contain
+" directories from a previous call. In theory, this should only be called
+" once.
+" ---------------------------------------------------------------------------
 func! vundle#config#init()
   if !exists('g:bundles') | let g:bundles = [] | endif
   call s:rtp_rm_a()
   let g:bundles = []
 endf
 
+
+" ---------------------------------------------------------------------------
 " Add a list of bundles to the runtimepath and source them.
 "
 " bundles -- a list of bundle objects
-" return  -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! vundle#config#require(bundles) abort
   for b in a:bundles
     call s:rtp_add(b.rtpath)
@@ -46,11 +60,14 @@ func! vundle#config#require(bundles) abort
   call s:rtp_add_defaults()
 endf
 
+
+" ---------------------------------------------------------------------------
 " Create a bundle object from a bundle specification.
 "
 " name   -- the bundle specification as a string
 " opts   -- the options dictionary from then bundle definition
 " return -- an initialized bundle object
+" ---------------------------------------------------------------------------
 func! vundle#config#init_bundle(name, opts)
   if a:name != substitute(a:name, '^\s*\(.\{-}\)\s*$', '\1', '')
     echo "Spurious leading and/or trailing whitespace found in plugin spec '" . a:name . "'"
@@ -61,12 +78,15 @@ func! vundle#config#init_bundle(name, opts)
   return b
 endf
 
+
+" ---------------------------------------------------------------------------
 " Parse the options which can be supplied with the bundle specification.
 " Corresponding documentation: vundle-plugins-configure
 "
 " opts   -- a dictionary with the user supplied options for the bundle
 " return -- a dictionary with the user supplied options for the bundle, this
 "           will be merged with a s:bundle object into one dictionary.
+" ---------------------------------------------------------------------------
 func! s:parse_options(opts)
   " TODO: improve this
   if len(a:opts) != 1 | return {} | endif
@@ -78,6 +98,8 @@ func! s:parse_options(opts)
   endif
 endf
 
+
+" ---------------------------------------------------------------------------
 " Parse the plugin specification.  Corresponding documentation:
 " vundle-plugins-uris
 "
@@ -85,6 +107,7 @@ endf
 " return -- a dictionary with the folder name (key 'name') and the uri (key
 "           'uri') for cloning the plugin  and the original argument (key
 "           'name_spec')
+" ---------------------------------------------------------------------------
 func! s:parse_name(arg)
   let arg = a:arg
   let git_proto = exists('g:vundle_default_git_proto') ? g:vundle_default_git_proto : 'https'
@@ -108,6 +131,12 @@ func! s:parse_name(arg)
   return {'name': name, 'uri': uri, 'name_spec': arg }
 endf
 
+
+" ---------------------------------------------------------------------------
+"  Modify the runtimepath, after all bundles have been added, so that the
+"  directories that were in the default runtimepath appear first in the list
+"  (with their 'after' directories last).
+" ---------------------------------------------------------------------------
 func! s:rtp_add_defaults()
   let current = &rtp
   set rtp&vim
@@ -124,10 +153,10 @@ func! s:rtp_add_defaults()
 endf
 
 
+" ---------------------------------------------------------------------------
 " Remove all paths for the plugins which are managed by Vundle from the
 " runtimepath.
-"
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! s:rtp_rm_a()
   let paths = map(copy(g:bundles), 'v:val.rtpath')
   let prepends = join(paths, ',')
@@ -136,10 +165,11 @@ func! s:rtp_rm_a()
   exec 'set rtp-='.fnameescape(appends)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Add all paths for the plugins which are managed by Vundle to the
 " runtimepath.
-"
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! s:rtp_add_a()
   let paths = map(copy(g:bundles), 'v:val.rtpath')
   let prepends = join(paths, ',')
@@ -148,58 +178,77 @@ func! s:rtp_add_a()
   exec 'set rtp+='.fnameescape(appends)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Remove a directory and the corresponding 'after' directory from runtimepath.
 "
 " dir    -- the directory name to be removed as a string.  The corresponding
 "           'after' directory will also be removed.
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! s:rtp_rm(dir) abort
   exec 'set rtp-='.fnameescape(expand(a:dir, 1))
   exec 'set rtp-='.fnameescape(expand(a:dir.'/after', 1))
 endf
 
+
+" ---------------------------------------------------------------------------
 " Add a directory and the corresponding 'after' directory to runtimepath.
 "
 " dir    -- the directory name to be added as a string.  The corresponding
 "           'after' directory will also be added.
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! s:rtp_add(dir) abort
   exec 'set rtp^='.fnameescape(expand(a:dir, 1))
   exec 'set rtp+='.fnameescape(expand(a:dir.'/after', 1))
 endf
 
+
+" ---------------------------------------------------------------------------
 " Expand and simplify a path.
 "
 " path   -- the path to expand as a string
 " return -- the expanded and simplified path
+" ---------------------------------------------------------------------------
 func! s:expand_path(path) abort
   return simplify(expand(a:path, 1))
 endf
 
+
+" ---------------------------------------------------------------------------
 " Find the actual path inside a bundle directory to be added to the
 " runtimepath.  It might be provided by the user with the 'rtp' option.
 " Corresponding documentation: vundle-plugins-configure
 "
 " opts   -- a bundle dict
 " return -- expanded path to the corresponding plugin directory
+" ---------------------------------------------------------------------------
 func! s:rtpath(opts)
   return has_key(a:opts, 'rtp') ? s:expand_path(a:opts.path().'/'.a:opts.rtp) : a:opts.path()
 endf
 
+
+" ---------------------------------------------------------------------------
 " a bundle 'object'
+" ---------------------------------------------------------------------------
 let s:bundle = {}
 
-" FIXME: This function is only called once and in most cases the return value
-" is stored in the bundle object as obj.rtpath unmodfied.  Is this necessary?
-"
+
+" ---------------------------------------------------------------------------
 " Return the absolute path to the directory inside the bundle directory
 " (prefix) where thr bundle will be cloned.
 "
 " return -- the target location to clone this bundle to
+" ---------------------------------------------------------------------------
 func! s:bundle.path()
   return s:expand_path(g:bundle_dir.'/'.self.name)
 endf
 
+
+" ---------------------------------------------------------------------------
+"  Determine if the bundle has the pinned attribute set in the config
+"
+"  return -- 1 if the bundle is pinned, 0 otherwise
+" ---------------------------------------------------------------------------
 func! s:bundle.is_pinned()
   return get(self, 'pinned')
 endf
diff --git a/autoload/vundle/installer.vim b/autoload/vundle/installer.vim
index ea1bde0..a9afd11 100644
--- a/autoload/vundle/installer.vim
+++ b/autoload/vundle/installer.vim
@@ -1,9 +1,10 @@
+" ---------------------------------------------------------------------------
 " 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).
 "
 " bang   -- 1 or 0
 " ...    -- any number of bundle specifications (seperate arguments)
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! vundle#installer#new(bang, ...) abort
   let bundles = (a:1 == '') ?
         \ g:bundles :
@@ -12,22 +13,23 @@ func! vundle#installer#new(bang, ...) abort
   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'])
 
-  " FIXME this tries to call 'add' as a normal mode command.  This is a buffer
-  " local mapping defined in vundle#scripts#view().  The mapping will call a
-  " buffer local command InstallPlugin which in turn will call
-  " vundle#installer#run() with vundle#installer#install().  This is very
-  " confusing and unclear.
+  " 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
+  " command InstallPlugin which in turn will call vundle#installer#run() with
+  " vundle#installer#install().
   call s:process(a:bang, (a:bang ? 'add!' : 'add'))
 
   call vundle#config#require(bundles)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Iterate over all lines in a Vundle window and execute the given command for
 " every line.  Used by the installation and cleaning functions.
 "
 " bang   -- not used (FIXME)
 " cmd    -- the (normal mode) command to execute for every line as a string
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! s:process(bang, cmd)
   let msg = ''
 
@@ -59,6 +61,8 @@ func! s:process(bang, cmd)
   echo 'Done! '.msg
 endf
 
+
+" ---------------------------------------------------------------------------
 " Call another function in the different Vundle windows.
 "
 " func_name -- the function to call
@@ -66,6 +70,7 @@ endf
 " ...       -- the argument to be used when calling func_name (only the first
 "              optional argument will be used)
 " return    -- the status returned by the call to func_name
+" ---------------------------------------------------------------------------
 func! vundle#installer#run(func_name, name, ...) abort
   let n = a:name
 
@@ -106,11 +111,13 @@ func! vundle#installer#run(func_name, name, ...) abort
   return status
 endf
 
+
+" ---------------------------------------------------------------------------
 " Put a sign on the current line, indicating the status of the installation
 " step.
 "
 " status -- string describing the status
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! s:sign(status)
   if (!has('signs'))
     return
@@ -119,11 +126,14 @@ func! s:sign(status)
   exe ":sign place ".line('.')." line=".line('.')." name=Vu_". a:status ." buffer=" . bufnr("%")
 endf
 
+
+" ---------------------------------------------------------------------------
 " Install a plugin, then add it to the runtimepath and source it.
 "
 " bang   -- 1 or 0, passed directly to vundle#installer#install()
 " name   -- the name of a bundle (string)
 " return -- the return value from vundle#installer#install()
+" ---------------------------------------------------------------------------
 func! vundle#installer#install_and_require(bang, name) abort
   let result = vundle#installer#install(a:bang, a:name)
   let b = vundle#config#bundle(a:name, {})
@@ -132,11 +142,14 @@ func! vundle#installer#install_and_require(bang, name) abort
   return result
 endf
 
+
+" ---------------------------------------------------------------------------
 " Install or update a bundle given by its name.
 "
 " bang   -- 1 or 0, passed directly to s:sync()
 " name   -- the name of a bundle (string)
 " 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
 
@@ -152,9 +165,12 @@ func! vundle#installer#install(bang, name) abort
   return s:sync(a:bang, b)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Call :helptags for all bundles in g:bundles.
 "
 " return -- 'error' if an error occurred, else return 'helptags'
+" ---------------------------------------------------------------------------
 func! vundle#installer#docs() abort
   let error_count = vundle#installer#helptags(g:bundles)
   if error_count > 0
@@ -163,11 +179,14 @@ func! vundle#installer#docs() abort
   return 'helptags'
 endf
 
+
+" ---------------------------------------------------------------------------
 " Call :helptags for a list of bundles.
 "
 " bundles -- a list of bundle dictionaries for which :helptags should be
 "            called.
 " return  -- the number of directories where :helptags failed
+" ---------------------------------------------------------------------------
 func! vundle#installer#helptags(bundles) abort
   let bundle_dirs = map(copy(a:bundles),'v:val.rtpath')
   let help_dirs = filter(bundle_dirs, 's:has_doc(v:val)')
@@ -183,11 +202,13 @@ func! vundle#installer#helptags(bundles) abort
   return len(errors)
 endf
 
+
+" ---------------------------------------------------------------------------
 " List all installed plugins.
 " Corresponding documentation: vundle-plugins-list
 "
 " bang   -- not used
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! vundle#installer#list(bang) abort
   let bundles = vundle#scripts#bundle_names(map(copy(g:bundles), 'v:val.name_spec'))
   call vundle#scripts#view('list', ['" My Plugins'], bundles)
@@ -195,12 +216,14 @@ func! vundle#installer#list(bang) abort
   echo len(g:bundles).' plugins configured'
 endf
 
+
+" ---------------------------------------------------------------------------
 " List and remove all directories in the bundle directory which are not
 " activated (added to the bundle list).
 "
 " bang   -- 0 if the user should be asked to confirm every deletion, 1 if they
 "           should be removed unconditionally
-" return -- 0 (unconditionally)
+" ---------------------------------------------------------------------------
 func! vundle#installer#clean(bang) abort
   let bundle_dirs = map(copy(g:bundles), 'v:val.path()')
   let all_dirs = (v:version > 702 || (v:version == 702 && has("patch51")))
@@ -231,12 +254,15 @@ func! vundle#installer#clean(bang) abort
   endif
 endf
 
+
+" ---------------------------------------------------------------------------
 " Delete to directory for a plugin.
 "
 " bang     -- not used
 " dir_name -- the bundle directory to be deleted (as a string)
 " return   -- 'error' if an error occurred, 'deleted' if the plugin folder was
 "             successfully deleted
+" ---------------------------------------------------------------------------
 func! vundle#installer#delete(bang, dir_name) abort
 
   let cmd = ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh'))) ?
@@ -260,10 +286,13 @@ func! vundle#installer#delete(bang, dir_name) abort
   endif
 endf
 
+
+" ---------------------------------------------------------------------------
 " Check if a bundled plugin has any documentation.
 "
 " rtp    -- a path (string) where the plugin is installed
 " return -- 1 if some documentation was found, 0 otherwise
+" ---------------------------------------------------------------------------
 func! s:has_doc(rtp) abort
   return isdirectory(a:rtp.'/doc')
   \   && (!filereadable(a:rtp.'/doc/tags') || filewritable(a:rtp.'/doc/tags'))
@@ -272,10 +301,13 @@ func! s:has_doc(rtp) abort
   \     : !(empty(glob(a:rtp.'/doc/*.txt')) && empty(glob(a:rtp.'/doc/*.??x')))
 endf
 
+
+" ---------------------------------------------------------------------------
 " Update the helptags for a plugin.
 "
 " rtp    -- the path to the plugin's root directory (string)
 " return -- 1 if :helptags succeeded, 0 otherwise
+" ---------------------------------------------------------------------------
 func! s:helptags(rtp) abort
   " it is important to keep trailing slash here
   let doc_path = resolve(a:rtp . '/doc/')
@@ -289,6 +321,8 @@ func! s:helptags(rtp) abort
   return 1
 endf
 
+
+" ---------------------------------------------------------------------------
 " Install or update a given bundle object with git.
 "
 " bang   -- 0 if only new plugins should be installed, 1 if existing plugins
@@ -298,6 +332,7 @@ endf
 "           'new' when the plugin was newly installed, 'updated' if some
 "           changes where pulled via git, 'error' if an error occurred in the
 "           shell command
+" ---------------------------------------------------------------------------
 func! s:sync(bang, bundle) abort
   " Do not sync if this bundle is pinned
   if a:bundle.is_pinned()
@@ -343,11 +378,14 @@ func! s:sync(bang, bundle) abort
   return 'updated'
 endf
 
+
+" ---------------------------------------------------------------------------
 " Escape special characters in a string to be able to use it as a shell
 " command with system().
 "
 " cmd    -- the string holding the shell command
 " return -- a string with the relevant characters escaped
+" ---------------------------------------------------------------------------
 func! vundle#installer#shellesc(cmd) abort
   if ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh')))
     return '"' . substitute(a:cmd, '"', '\\"', 'g') . '"'
@@ -355,10 +393,13 @@ func! vundle#installer#shellesc(cmd) abort
   return shellescape(a:cmd)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Fix a cd shell command to be used on Windows.
 "
 " cmd    -- the command to be fixed (string)
 " return -- the fixed command (string)
+" ---------------------------------------------------------------------------
 func! g:shellesc_cd(cmd) abort
   if ((has('win32') || has('win64')) && empty(matchstr(&shell, 'sh')))
     let cmd = substitute(a:cmd, '^cd ','cd /d ','')  " add /d switch to change drives
@@ -368,21 +409,27 @@ func! g:shellesc_cd(cmd) abort
   endif
 endf
 
+
+" ---------------------------------------------------------------------------
 " Make a system call.  This can be used to change the way system calls
 " are made during developing, without searching the whole code base for
 " actual system() calls.
 "
 " cmd    -- the command passed to system() (string)
 " return -- the return value from system()
+" ---------------------------------------------------------------------------
 func! s:system(cmd) abort
   return system(a:cmd)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Add a log message to Vundle's internal logging variable.
 "
 " str    -- the log message (string)
 " prefix -- optional prefix for multiline entries (string)
 " return -- a:str
+" ---------------------------------------------------------------------------
 func! s:log(str, ...) abort
   let prefix = a:0 > 0 ? a:1 : ''
   let fmt = '%Y-%m-%d %H:%M:%S'
diff --git a/autoload/vundle/scripts.vim b/autoload/vundle/scripts.vim
index 6381391..40f91b9 100644
--- a/autoload/vundle/scripts.vim
+++ b/autoload/vundle/scripts.vim
@@ -1,10 +1,11 @@
-" Searches the database from vim-script.org for a matching plugin.  If no
-" argument is given all plugins are listed.  This function is used by the
-" :Plugins and :PluginSearch commands.
+" ---------------------------------------------------------------------------
+" Search the database from vim-script.org for a matching plugin.  If no
+" argument is given, list all plugins. This function is used by the :Plugins
+" and :PluginSearch commands.
 "
 " bang -- if 1 refresh the script name cache, if 0 don't
-" ...  -- a plugin name to search for (FIXME what about multible arguments, it
-"         doesn't seem to work.)
+" ...  -- a plugin name to search for
+" ---------------------------------------------------------------------------
 func! vundle#scripts#all(bang, ...)
   let b:match = ''
   let info = ['"Keymap: i - Install plugin; c - Cleanup; s - Search; R - Reload list']
@@ -20,22 +21,31 @@ func! vundle#scripts#all(bang, ...)
   echo len(matches).' plugins found'
 endf
 
+
+" ---------------------------------------------------------------------------
 " Repeat the search for bundles.
+" ---------------------------------------------------------------------------
 func! vundle#scripts#reload() abort
   silent exec ':PluginSearch! '.(exists('b:match') ? b:match : '')
   redraw
 endf
 
+
+" ---------------------------------------------------------------------------
 " Complete names for bundles in the command line.
 "
 " a, c, d -- see :h command-completion-custom
 " return  -- all valid plugin names from vim-scripts.org as completion
 "            candidates, see also :h command-completion-custom
+" ---------------------------------------------------------------------------
 func! vundle#scripts#complete(a,c,d)
   return join(s:load_scripts(0),"\n")
 endf
 
+
+" ---------------------------------------------------------------------------
 " View the logfile after an update or installation.
+" ---------------------------------------------------------------------------
 func! s:view_log()
   if !exists('g:vundle_log_file')
     let g:vundle_log_file = tempname()
@@ -47,10 +57,11 @@ func! s:view_log()
   wincmd P | wincmd H
 endf
 
+
+" ---------------------------------------------------------------------------
 " Parse the output from git log after an update to create a change log for the
-" tuser.
-"
-" return -- 0 (unconditionally)
+" user.
+" ---------------------------------------------------------------------------
 func! s:create_changelog() abort
   for bundle_data in g:updated_bundles
     let initial_sha = bundle_data[0]
@@ -79,7 +90,10 @@ func! s:create_changelog() abort
   endfor
 endf
 
+
+" ---------------------------------------------------------------------------
 " View the change log after an update or installation.
+" ---------------------------------------------------------------------------
 func! s:view_changelog()
   call s:create_changelog()
 
@@ -93,14 +107,19 @@ func! s:view_changelog()
   wincmd P | wincmd H
 endf
 
+
+" ---------------------------------------------------------------------------
 " Create a list of 'Plugin ...' lines from a list of bundle names.
 "
 " names  -- a list of names (strings) of plugins
 " return -- a list of 'Plugin ...' lines suitable to be written to a buffer
+" ---------------------------------------------------------------------------
 func! vundle#scripts#bundle_names(names)
   return map(copy(a:names), ' printf("Plugin ' ."'%s'".'", v:val) ')
 endf
 
+
+" ---------------------------------------------------------------------------
 " Open a buffer to display information to the user.  Several special commands
 " are defined in the new buffer.
 "
@@ -108,6 +127,7 @@ endf
 " headers -- a list of header lines to be displayed at the top of the buffer
 " results -- the main information to be displayed in the buffer (list of
 "            strings)
+" ---------------------------------------------------------------------------
 func! vundle#scripts#view(title, headers, results)
   if exists('g:vundle_view') && bufloaded(g:vundle_view)
     exec g:vundle_view.'bd!'
@@ -178,10 +198,13 @@ func! vundle#scripts#view(title, headers, results)
   exec ':'.(len(a:headers) + 1)
 endf
 
+
+" ---------------------------------------------------------------------------
 " Load the plugin database from vim-scripts.org .
 "
 " to     -- the filename (string) to save the database to
 " return -- 0 on success, 1 if an error occurred
+" ---------------------------------------------------------------------------
 func! s:fetch_scripts(to)
   let scripts_dir = fnamemodify(expand(a:to, 1), ":h")
   if !isdirectory(scripts_dir)
@@ -212,12 +235,15 @@ func! s:fetch_scripts(to)
   return 0
 endf
 
+
+" ---------------------------------------------------------------------------
 " Load the plugin database and return a list of all plugins.
 "
 " bang   -- if 1 download the redatabase, else only download if it is not
 "           readable on disk (i.e. does not exist)
 " return -- a list of strings, these are the names (valid bundle
 "           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)
   if a:bang || !filereadable(f)