From 8385ed00af04f8c0dfb69081e99dbf59b9e2b279 Mon Sep 17 00:00:00 2001 From: Christophe Buffenoir Date: Fri, 3 May 2013 10:58:55 +0200 Subject: [PATCH] Add jedi Fix error in powerline (ascii can't decode) Get vim plugins directly from git --- .hgignore | 2 + .../ipython/profile_default/ipython_config.py | 5 + common/.config/powerline/config.json | 8 +- common/.local/bin/powerline-zsh.py | 325 +++ .../jedi-0.5b5.egg-info/PKG-INFO | 282 +++ .../jedi-0.5b5.egg-info/SOURCES.txt | 31 + .../jedi-0.5b5.egg-info/dependency_links.txt | 1 + .../jedi-0.5b5.egg-info/installed-files.txt | 41 + .../jedi-0.5b5.egg-info/top_level.txt | 1 + .../python2.7/site-packages/jedi/__init__.py | 16 + .../site-packages/jedi/_compatibility.py | 169 ++ .../lib/python2.7/site-packages/jedi/api.py | 457 ++++ .../site-packages/jedi/api_classes.py | 311 +++ .../python2.7/site-packages/jedi/builtin.py | 472 +++++ .../lib/python2.7/site-packages/jedi/debug.py | 64 + .../site-packages/jedi/docstrings.py | 34 + .../python2.7/site-packages/jedi/dynamic.py | 507 +++++ .../python2.7/site-packages/jedi/evaluate.py | 1614 ++++++++++++++ .../python2.7/site-packages/jedi/helpers.py | 266 +++ .../python2.7/site-packages/jedi/imports.py | 332 +++ .../python2.7/site-packages/jedi/keywords.py | 86 + .../site-packages/jedi/mixin/_functools.pym | 9 + .../site-packages/jedi/mixin/_sre.pym | 99 + .../site-packages/jedi/mixin/_weakref.pym | 8 + .../site-packages/jedi/mixin/builtins.pym | 218 ++ .../site-packages/jedi/mixin/datetime.pym | 4 + .../site-packages/jedi/mixin/posix.pym | 5 + .../python2.7/site-packages/jedi/modules.py | 312 +++ .../python2.7/site-packages/jedi/parsing.py | 1855 +++++++++++++++++ .../python2.7/site-packages/jedi/settings.py | 87 + .../site-packages/powerline/segments/vim.py | 2 +- common/.vim/bundle/nerdtree/.git/HEAD | 1 - common/.vim/bundle/nerdtree/.git/config | 11 - common/.vim/bundle/nerdtree/.git/description | 1 - .../nerdtree/.git/hooks/applypatch-msg.sample | 15 - .../nerdtree/.git/hooks/commit-msg.sample | 24 - .../nerdtree/.git/hooks/post-update.sample | 8 - .../nerdtree/.git/hooks/pre-applypatch.sample | 14 - .../nerdtree/.git/hooks/pre-commit.sample | 50 - .../nerdtree/.git/hooks/pre-rebase.sample | 169 -- .../.git/hooks/prepare-commit-msg.sample | 36 - .../bundle/nerdtree/.git/hooks/update.sample | 128 -- common/.vim/bundle/nerdtree/.git/index | Bin 1600 -> 0 bytes common/.vim/bundle/nerdtree/.git/info/exclude | 6 - common/.vim/bundle/nerdtree/.git/logs/HEAD | 1 - .../nerdtree/.git/logs/refs/heads/master | 1 - .../.git/logs/refs/remotes/origin/HEAD | 1 - ...bae269ee6a303f1bab5c4620044bd810e1771f.idx | Bin 73172 -> 0 bytes ...ae269ee6a303f1bab5c4620044bd810e1771f.pack | Bin 1004643 -> 0 bytes common/.vim/bundle/nerdtree/.git/packed-refs | 23 - .../bundle/nerdtree/.git/refs/heads/master | 1 - .../nerdtree/.git/refs/remotes/origin/HEAD | 1 - common/.vim/bundle/nerdtree/.gitignore | 3 - common/.vim/bundle/nerdtree/README.markdown | 108 - .../bundle/nerdtree/autoload/nerdtree.vim | 1391 ------------ common/.vim/bundle/nerdtree/doc/NERD_tree.txt | 1362 ------------ .../nerdtree_plugin/exec_menuitem.vim | 41 - .../nerdtree/nerdtree_plugin/fs_menu.vim | 262 --- .../.vim/bundle/nerdtree/plugin/NERD_tree.vim | 218 -- .../nerdtree/plugin/nerdtree/bookmark.vim | 315 --- .../nerdtree/plugin/nerdtree/creator.vim | 298 --- .../nerdtree/plugin/nerdtree/key_map.vim | 143 -- .../plugin/nerdtree/menu_controller.vim | 180 -- .../nerdtree/plugin/nerdtree/menu_item.vim | 114 - .../nerdtree/plugin/nerdtree/opener.vim | 264 --- .../bundle/nerdtree/plugin/nerdtree/path.vim | 724 ------- .../plugin/nerdtree/tree_dir_node.vim | 528 ----- .../plugin/nerdtree/tree_file_node.vim | 485 ----- .../.vim/bundle/nerdtree/syntax/nerdtree.vim | 88 - common/.vim/closetag.vim | 327 --- common/.vimrc | 34 +- common/.zshrc | 1 - update-home.sh | 62 + 73 files changed, 7702 insertions(+), 7360 deletions(-) create mode 100644 .hgignore create mode 100644 common/.config/ipython/profile_default/ipython_config.py create mode 100755 common/.local/bin/powerline-zsh.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/PKG-INFO create mode 100644 common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/SOURCES.txt create mode 100644 common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/dependency_links.txt create mode 100644 common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/installed-files.txt create mode 100644 common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/top_level.txt create mode 100644 common/.local/lib/python2.7/site-packages/jedi/__init__.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/_compatibility.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/api.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/api_classes.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/builtin.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/debug.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/docstrings.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/dynamic.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/evaluate.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/helpers.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/imports.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/keywords.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/mixin/_functools.pym create mode 100644 common/.local/lib/python2.7/site-packages/jedi/mixin/_sre.pym create mode 100644 common/.local/lib/python2.7/site-packages/jedi/mixin/_weakref.pym create mode 100644 common/.local/lib/python2.7/site-packages/jedi/mixin/builtins.pym create mode 100644 common/.local/lib/python2.7/site-packages/jedi/mixin/datetime.pym create mode 100644 common/.local/lib/python2.7/site-packages/jedi/mixin/posix.pym create mode 100644 common/.local/lib/python2.7/site-packages/jedi/modules.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/parsing.py create mode 100644 common/.local/lib/python2.7/site-packages/jedi/settings.py delete mode 100644 common/.vim/bundle/nerdtree/.git/HEAD delete mode 100644 common/.vim/bundle/nerdtree/.git/config delete mode 100644 common/.vim/bundle/nerdtree/.git/description delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/applypatch-msg.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/commit-msg.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/post-update.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/pre-applypatch.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/pre-commit.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/pre-rebase.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/prepare-commit-msg.sample delete mode 100755 common/.vim/bundle/nerdtree/.git/hooks/update.sample delete mode 100644 common/.vim/bundle/nerdtree/.git/index delete mode 100644 common/.vim/bundle/nerdtree/.git/info/exclude delete mode 100644 common/.vim/bundle/nerdtree/.git/logs/HEAD delete mode 100644 common/.vim/bundle/nerdtree/.git/logs/refs/heads/master delete mode 100644 common/.vim/bundle/nerdtree/.git/logs/refs/remotes/origin/HEAD delete mode 100644 common/.vim/bundle/nerdtree/.git/objects/pack/pack-fabae269ee6a303f1bab5c4620044bd810e1771f.idx delete mode 100644 common/.vim/bundle/nerdtree/.git/objects/pack/pack-fabae269ee6a303f1bab5c4620044bd810e1771f.pack delete mode 100644 common/.vim/bundle/nerdtree/.git/packed-refs delete mode 100644 common/.vim/bundle/nerdtree/.git/refs/heads/master delete mode 100644 common/.vim/bundle/nerdtree/.git/refs/remotes/origin/HEAD delete mode 100644 common/.vim/bundle/nerdtree/.gitignore delete mode 100644 common/.vim/bundle/nerdtree/README.markdown delete mode 100644 common/.vim/bundle/nerdtree/autoload/nerdtree.vim delete mode 100644 common/.vim/bundle/nerdtree/doc/NERD_tree.txt delete mode 100644 common/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim delete mode 100644 common/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/NERD_tree.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/bookmark.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/creator.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/key_map.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/menu_controller.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/menu_item.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/opener.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/path.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/tree_dir_node.vim delete mode 100644 common/.vim/bundle/nerdtree/plugin/nerdtree/tree_file_node.vim delete mode 100644 common/.vim/bundle/nerdtree/syntax/nerdtree.vim delete mode 100644 common/.vim/closetag.vim diff --git a/.hgignore b/.hgignore new file mode 100644 index 0000000..2c9154d --- /dev/null +++ b/.hgignore @@ -0,0 +1,2 @@ +syntax: glob +*.pyc diff --git a/common/.config/ipython/profile_default/ipython_config.py b/common/.config/ipython/profile_default/ipython_config.py new file mode 100644 index 0000000..e7d47d1 --- /dev/null +++ b/common/.config/ipython/profile_default/ipython_config.py @@ -0,0 +1,5 @@ +c = get_config() + +c.InteractiveShellApp.extensions = [ + 'powerline.bindings.ipython.post_0_11' +] diff --git a/common/.config/powerline/config.json b/common/.config/powerline/config.json index 8882ad9..628d727 100644 --- a/common/.config/powerline/config.json +++ b/common/.config/powerline/config.json @@ -24,10 +24,6 @@ } }, "shell": { - "colorscheme": "default", - "theme": "default" - }, - "tmux": { "colorscheme": "default", "theme": "default", "segments" : { @@ -37,6 +33,10 @@ } } }, + "tmux": { + "colorscheme": "default", + "theme": "default" + }, "vim": { "colorscheme": "default", "theme": "default", diff --git a/common/.local/bin/powerline-zsh.py b/common/.local/bin/powerline-zsh.py new file mode 100755 index 0000000..ada55b8 --- /dev/null +++ b/common/.local/bin/powerline-zsh.py @@ -0,0 +1,325 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import os +import subprocess +import sys +import re +import argparse + + +def warn(msg): + print '[powerline-zsh] ', msg + + +class Color: + # The following link is a pretty good resources for color values: + # http://www.calmar.ws/vim/color-output.png + + PATH_BG = 237 # dark grey + PATH_FG = 250 # light grey + CWD_FG = 254 # nearly-white grey + SEPARATOR_FG = 244 + + REPO_CLEAN_BG = 148 # a light green color + REPO_CLEAN_FG = 0 # black + REPO_DIRTY_BG = 161 # pink/red + REPO_DIRTY_FG = 15 # white + + CMD_PASSED_BG = 236 + CMD_PASSED_FG = 15 + CMD_FAILED_BG = 161 + CMD_FAILED_FG = 15 + + SVN_CHANGES_BG = 148 + SVN_CHANGES_FG = 22 # dark green + + VIRTUAL_ENV_BG = 35 # a mid-tone green + VIRTUAL_ENV_FG = 22 + + +class Powerline: + symbols = { + 'compatible': { + 'separator': u'\u25B6', + 'separator_thin': u'\u276F' + }, + 'patched': { + 'separator': u'\u2B80', + 'separator_thin': u'\u2B81' + }, + 'default': { + 'separator': '⮀', + 'separator_thin': '⮁' + } + } + LSQESCRSQ = '\\[\\e%s\\]' + reset = ' %f%k' + + def __init__(self, mode='default'): + self.separator = Powerline.symbols[mode]['separator'] + self.separator_thin = Powerline.symbols[mode]['separator_thin'] + self.segments = [] + + def color(self, prefix, code): + if prefix == '38': + return '%%F{%s}' % code + elif prefix == '48': + return '%%K{%s}' % code + + def fgcolor(self, code): + return self.color('38', code) + + def bgcolor(self, code): + return self.color('48', code) + + def append(self, segment): + self.segments.append(segment) + + def draw(self): + return (''.join((s[0].draw(self, s[1]) for s in zip(self.segments, self.segments[1:] + [None]))) + + self.reset) + + +class Segment: + def __init__(self, powerline, content, fg, bg, separator=None, separator_fg=None): + self.powerline = powerline + self.content = content + self.fg = fg + self.bg = bg + self.separator = separator or powerline.separator + self.separator_fg = separator_fg or bg + + def draw(self, powerline, next_segment=None): + if next_segment: + separator_bg = powerline.bgcolor(next_segment.bg) + else: + separator_bg = powerline.reset + + return ''.join(( + powerline.fgcolor(self.fg), + powerline.bgcolor(self.bg), + self.content, + separator_bg, + powerline.fgcolor(self.separator_fg), + self.separator)) + + +def add_cwd_segment(powerline, cwd, maxdepth, cwd_only=False): + #powerline.append(' \\w ', 15, 237) + home = os.getenv('HOME') + cwd = os.getenv('PWD') + + if cwd.find(home) == 0: + cwd = cwd.replace(home, '~', 1) + + if cwd[0] == '/': + cwd = cwd[1:] + + names = cwd.split('/') + if len(names) > maxdepth: + names = names[:2] + ['⋯ '] + names[2 - maxdepth:] + + if not cwd_only: + for n in names[:-1]: + powerline.append(Segment(powerline, ' %s ' % n, Color.PATH_FG, Color.PATH_BG, powerline.separator_thin, Color.SEPARATOR_FG)) + powerline.append(Segment(powerline, ' %s ' % names[-1], Color.CWD_FG, Color.PATH_BG)) + + +def get_hg_status(): + has_modified_files = False + has_untracked_files = False + has_missing_files = False + output = subprocess.Popen(['hg', 'status'], stdout=subprocess.PIPE).communicate()[0] + for line in output.split('\n'): + if line == '': + continue + elif line[0] == '?': + has_untracked_files = True + elif line[0] == '!': + has_missing_files = True + else: + has_modified_files = True + return has_modified_files, has_untracked_files, has_missing_files + + +def add_hg_segment(powerline, cwd): + branch = os.popen('hg branch 2> /dev/null').read().rstrip() + if len(branch) == 0: + return False + bg = Color.REPO_CLEAN_BG + fg = Color.REPO_CLEAN_FG + has_modified_files, has_untracked_files, has_missing_files = get_hg_status() + if has_modified_files or has_untracked_files or has_missing_files: + bg = Color.REPO_DIRTY_BG + fg = Color.REPO_DIRTY_FG + extra = '' + if has_untracked_files: + extra += '+' + if has_missing_files: + extra += '!' + branch += (' ' + extra if extra != '' else '') + powerline.append(Segment(powerline, ' %s ' % branch, fg, bg)) + return True + + +def get_git_status(): + has_pending_commits = True + has_untracked_files = False + detached_head = False + origin_position = "" + current_branch = '' + output = subprocess.Popen(['git', 'status', '-unormal'], stdout=subprocess.PIPE).communicate()[0] + for line in output.split('\n'): + origin_status = re.findall("Your branch is (ahead|behind).*?(\d+) comm", line) + if len(origin_status) > 0: + origin_position = " %d" % int(origin_status[0][1]) + if origin_status[0][0] == 'behind': + origin_position += '⇣' + if origin_status[0][0] == 'ahead': + origin_position += '⇡' + + if line.find('nothing to commit (working directory clean)') >= 0: + has_pending_commits = False + if line.find('Untracked files') >= 0: + has_untracked_files = True + if line.find('Not currently on any branch') >= 0: + detached_head = True + if line.find('On branch') >= 0: + current_branch = re.findall('On branch ([^ ]+)', line)[0] + return has_pending_commits, has_untracked_files, origin_position, detached_head, current_branch + + +def add_git_segment(powerline, cwd): + #cmd = "git branch 2> /dev/null | grep -e '\\*'" + p1 = subprocess.Popen(['git', 'branch'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p2 = subprocess.Popen(['grep', '-e', '\\*'], stdin=p1.stdout, stdout=subprocess.PIPE) + output = p2.communicate()[0].strip() + if len(output) == 0: + return False + + has_pending_commits, has_untracked_files, origin_position, detached_head, current_branch = get_git_status() + + if len(current_branch) > 0: + branch = current_branch + elif detached_head: + branch = subprocess.Popen(['git', 'describe', '--all', '--contains', '--abbrev=4', 'HEAD'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + branch = '((' + branch.communicate()[0].strip() + '))' + else: + return 'master' + + branch += origin_position + + if has_untracked_files: + branch += ' +' + + bg = Color.REPO_CLEAN_BG + fg = Color.REPO_CLEAN_FG + + if has_pending_commits: + bg = Color.REPO_DIRTY_BG + fg = Color.REPO_DIRTY_FG + + powerline.append(Segment(powerline, ' %s ' % branch, fg, bg)) + return True + + +def add_svn_segment(powerline, cwd): + if not os.path.exists(os.path.join(cwd, '.svn')): + return + '''svn info: + First column: Says if item was added, deleted, or otherwise changed + ' ' no modifications + 'A' Added + 'C' Conflicted + 'D' Deleted + 'I' Ignored + 'M' Modified + 'R' Replaced + 'X' an unversioned directory created by an externals definition + '?' item is not under version control + '!' item is missing (removed by non-svn command) or incomplete + '~' versioned item obstructed by some item of a different kind + ''' + #TODO: Color segment based on above status codes + try: + #cmd = '"svn status | grep -c "^[ACDIMRX\\!\\~]"' + p1 = subprocess.Popen(['svn', 'status'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p2 = subprocess.Popen(['grep', '-c', '^[ACDIMRX\\!\\~]'], stdin=p1.stdout, stdout=subprocess.PIPE) + output = p2.communicate()[0].strip() + if len(output) > 0 and int(output) > 0: + changes = output.strip() + powerline.append(Segment(powerline, ' %s ' % changes, Color.SVN_CHANGES_FG, Color.SVN_CHANGES_BG)) + except OSError: + return False + except subprocess.CalledProcessError: + return False + return True + + +def add_repo_segment(powerline, cwd): + for add_repo_segment in [add_git_segment, add_svn_segment, add_hg_segment]: + try: + if add_repo_segment(p, cwd): + return + except subprocess.CalledProcessError: + pass + except OSError: + pass + + +def add_virtual_env_segment(powerline, cwd): + env = os.getenv("VIRTUAL_ENV") + if env is None: + return False + env_name = os.path.basename(env) + bg = Color.VIRTUAL_ENV_BG + fg = Color.VIRTUAL_ENV_FG + powerline.append(Segment(powerline, ' %s ' % env_name, fg, bg)) + return True + + +def add_root_indicator(powerline, error): + bg = Color.CMD_PASSED_BG + fg = Color.CMD_PASSED_FG + if int(error) != 0: + fg = Color.CMD_FAILED_FG + bg = Color.CMD_FAILED_BG + powerline.append(Segment(powerline, ' $ ', fg, bg)) + + +def get_valid_cwd(): + try: + cwd = os.getcwd() + except: + cwd = os.getenv('PWD') # This is where the OS thinks we are + parts = cwd.split(os.sep) + up = cwd + while parts and not os.path.exists(up): + parts.pop() + up = os.sep.join(parts) + try: + os.chdir(up) + except: + warn("Your current directory is invalid.") + sys.exit(1) + warn("Your current directory is invalid. Lowest valid directory: " + up) + return cwd + +if __name__ == '__main__': + arg_parser = argparse.ArgumentParser() + arg_parser.add_argument('--cwd-only', action="store_true") + arg_parser.add_argument('prev_error', nargs='?', default=0) + args = arg_parser.parse_args() + + p = Powerline(mode='default') + cwd = get_valid_cwd() + add_virtual_env_segment(p, cwd) + #p.append(Segment(' \\u ', 250, 240)) + #p.append(Segment(' \\h ', 250, 238)) + add_cwd_segment(p, cwd, 5, args.cwd_only) + add_repo_segment(p, cwd) + add_root_indicator(p, args.prev_error) + sys.stdout.write(p.draw()) + +# vim: set expandtab: diff --git a/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/PKG-INFO b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/PKG-INFO new file mode 100644 index 0000000..24a9e45 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/PKG-INFO @@ -0,0 +1,282 @@ +Metadata-Version: 1.1 +Name: jedi +Version: 0.5b5 +Summary: An autocompletion tool for Python that can be used for text editors. +Home-page: https://github.com/davidhalter/jedi +Author: David Halter +Author-email: davidhalter88@gmail.com +License: LGPLv3 +Description: ######################################## + Jedi - an awesome Python auto-completion + ######################################## + + .. image:: https://secure.travis-ci.org/davidhalter/jedi.png?branch=master + :target: http://travis-ci.org/davidhalter/jedi + :alt: Travis-CI build status + + **beta testing** + + *If you have any comments or feature requests, please tell me! I really want to + know, what you think about Jedi.* + + Jedi is an autocompletion tool for Python. It works. With and without syntax + errors. Sometimes it sucks, but that's normal in dynamic languages. But it + sucks less than other tools. It understands almost all of the basic Python + syntax elements including many builtins. + + Jedi suports two different goto functions and has support for renaming. + Probably it will also have some support for refactoring in the future. + + Jedi uses a very simple interface to connect with IDE's. As an reference, there + is a VIM implementation, which uses Jedi's autocompletion. However, I encourage + you to use Jedi in your IDEs. Start writing plugins! If there are problems with + licensing, just contact me. + + At the moment Jedi can be used as a + `VIM-Plugin `_. So, if you want to test + Jedi for now, you'll have to use VIM. But there are new plugins emerging: + + - `Emacs-Plugin `_ + - `Sublime-Plugin `_ **Under construction** + + Here are some pictures: + + .. image:: https://github.com/davidhalter/jedi/raw/master/screenshot_complete.png + + Completion for almost anything (Ctrl+Space). + + .. image:: https://github.com/davidhalter/jedi/raw/master/screenshot_function.png + + Display of function/class bodies, docstrings. + + .. image:: https://github.com/davidhalter/jedi/raw/master/screenshot_pydoc.png + + Pydoc support (with highlighting, Shift+k). + + There is also support for goto and renaming. + + Get the latest from `github `_. + + + Installation + ============ + + You can either include Jedi as a submodule in your text editor plugin (like + jedi-vim_ does it by default), or you + can install Jedi systemwide. + + The preferred way to install the Jedi library into your system is by using + pip_:: + + sudo pip install jedi + + If you want to install the current development version:: + + sudo pip install -e git://github.com/davidhalter/jedi.git#egg=jedi + + Note: This just installs the Jedi library, not the editor plugins. For + information about how to make it work with your editor, refer to the + corresponding documentation. + + + Support + ======= + + Jedi supports Python 2.5 up to 3.x. There is just one code base, for both + Python 2 and 3. + Jedi supports many of the widely used Python features: + + - builtin functions/classes support + - complex module / function / class structures + - ignores syntax and indentation errors + - multiple returns / yields + - tuple assignments / array indexing / dictionary indexing + - exceptions / with-statement + - \*args / \*\*kwargs + - decorators + - descriptors -> property / staticmethod / classmethod + - closures + - generators (yield statement) / iterators + - support for some magic methods: ``__call__``, ``__iter__``, ``__next__``, + ``__get__``, ``__getitem__``, ``__init__`` + - support for list.append, set.add, list.extend, etc. + - (nested) list comprehensions / ternary expressions + - relative imports + - ``getattr()`` / ``__getattr__`` / ``__getattribute__`` + - function annotations (py3k feature, are ignored right now, but being parsed. + I don't know what to do with them.) + - class decorators (py3k feature, are being ignored too, until I find a use + case, that doesn't work with Jedi) + - simple/usual ``sys.path`` modifications + - ``isinstance`` checks for if/while/assert + - virtualenv support + - infer function arguments with sphinx (and other) docstrings + + However, it does not yet support (and probably will in future versions, because + they are on my todo list): + + - manipulations of instances outside the instance variables, without using + functions + + It does not support (and most probably will not in future versions): + + - metaclasses (how could an auto-completion ever support this) + - ``setattr()``, ``__import__()`` + - Writing to some dicts: ``globals()``, ``locals()``, ``object.__dict__`` + - evaluate ``if`` / ``while`` + + + Caveats + ======= + + This framework should work for both Python 2/3. However, some things were just + not as *pythonic* in Python 2 as things should be. To keep things simple, some + things have been held back: + + - Classes: Always Python 3 like, therefore all classes inherit from ``object``. + - Generators: No ``next`` method. The ``__next__`` method is used instead. + - Exceptions are only looked at in the form of ``Exception as e``, no comma! + + Syntax errors and other strange stuff, that is defined differently in the + Python language, may lead to undefined behaviour of the completion. Jedi is + **NOT** a Python compiler, that tries to correct you. It is a tool that wants + to help you. But **YOU** have to know Python, not Jedi. + + Importing ``numpy`` can be quite slow sometimes, as well as loading the builtins + the first time. If you want to speed it up, you could write import hooks in + jedi, which preloads this stuff. However, once loaded, this is not a problem + anymore. The same is true for huge modules like ``PySide``, ``wx``, etc. + + Security is an important issue for Jedi. Therefore no Python code is executed. + As long as you write pure python, everything is evaluated statically. But: If + you use builtin modules (`c_builtin`) there is no other option than to execute + those modules. However: Execute isn't that critical (as e.g. in pythoncomplete, + which used to execute *every* import!), because it means one import and no + more. So basically the only dangerous thing is using the import itself. If your + `c_builtin` uses some strange initializations, it might be dangerous. But if it + does you're screwed anyways, because eventualy you're going to execute your + code, which executes the import. + + + A little history + ================ + + The Star Wars Jedi are awesome. My Jedi software tries to imitate a little bit + of the precognition the Jedi have. There is even an awesome `scene + `_ of Monty Python Jedi's :-). + + But actually the name hasn't so much to do with Star Wars. It's part of my + second name. + + After I explained Guido van Rossum, how some parts of my auto-completion work, + he said (we drank a beer or two): + + *Oh, that worries me* + + When it's finished, I hope he'll like it :-) + + I actually started Jedi, because there were no good solutions available for + VIM. Most auto-completions just didn't work well. The only good solution was + PyCharm. I just like my good old VIM. Rope was never really intended to be an + auto-completion (and also I really hate project folders for my Python scripts). + It's more of a refactoring suite. So I decided to do my own version of a + completion, which would execute non-dangerous code. But I soon realized, that + this wouldn't work. So I built an extremely recursive thing which understands + many of Python's key features. + + By the way, I really tried to program it as understandable as possible. But I + think understanding it might need quite some time, because of its recursive + nature. + + + API-Design for IDEs + =================== + + If you want to set up an IDE with Jedi, you need to ``import jedi``. You should + have the following objects available: + + :: + + Script(source, line, column, source_path) + + ``source`` would be the source of your python file/script, separated by new + lines. ``line`` is the current line you want to perform actions on (starting + with line #1 as the first line). ``column`` represents the current + column/indent of the cursor (starting with zero). ``source_path`` should be the + path of your file in the file system. + + It returns a script object that contains the relevant information for the other + functions to work without params. + + :: + + Script().complete + + Returns ``api.Completion`` objects. Those objects have got + informations about the completions. More than just names. + + :: + + Script().goto + + Similar to complete. The returned ``api.Definition`` objects contain + information about the definitions found. + + :: + + Script().get_definition + + Mostly used for tests. Like goto, but follows statements and imports and + doesn't break there. You probably don't want to use this function. It's + mostly for testing. + + :: + + Script().related_names + + Returns all names that point to the definition of the name under the + cursor. This is also very useful for refactoring (renaming). + + :: + + Script().get_in_function_call + + Get the ``Function`` object of the call you're currently in, e.g.: ``abs(`` + with the cursor at the end would return the builtin ``abs`` function. + + :: + + NotFoundError + + If you use the goto function and no valid identifier (name) is at the + place of the cursor (position). It will raise this exception. + + :: + + set_debug_function + + Sets a callback function for ``debug.py``. This function is called with + multiple text objects, in python 3 you could insert ``print``. + + :: + + settings + + Access to the ``settings.py`` module. The settings are described there. + + + + .. _jedi-vim: http://github.com/davidhalter/jedi-vim + .. _pip: http://www.pip-installer.org/ + +Keywords: python completion refactoring vim +Platform: any +Classifier: Development Status :: 4 - Beta +Classifier: Environment :: Plugins +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) +Classifier: Topic :: Utilities diff --git a/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/SOURCES.txt b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/SOURCES.txt new file mode 100644 index 0000000..c1d625b --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/SOURCES.txt @@ -0,0 +1,31 @@ +AUTHORS.txt +LICENSE.txt +MANIFEST.in +README.rst +setup.cfg +setup.py +jedi/__init__.py +jedi/_compatibility.py +jedi/api.py +jedi/api_classes.py +jedi/builtin.py +jedi/debug.py +jedi/docstrings.py +jedi/dynamic.py +jedi/evaluate.py +jedi/helpers.py +jedi/imports.py +jedi/keywords.py +jedi/modules.py +jedi/parsing.py +jedi/settings.py +jedi.egg-info/PKG-INFO +jedi.egg-info/SOURCES.txt +jedi.egg-info/dependency_links.txt +jedi.egg-info/top_level.txt +jedi/mixin/_functools.pym +jedi/mixin/_sre.pym +jedi/mixin/_weakref.pym +jedi/mixin/builtins.pym +jedi/mixin/datetime.pym +jedi/mixin/posix.pym \ No newline at end of file diff --git a/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/dependency_links.txt b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/installed-files.txt b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/installed-files.txt new file mode 100644 index 0000000..d4fc8a0 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/installed-files.txt @@ -0,0 +1,41 @@ +../jedi/builtin.py +../jedi/evaluate.py +../jedi/debug.py +../jedi/helpers.py +../jedi/settings.py +../jedi/keywords.py +../jedi/api_classes.py +../jedi/api.py +../jedi/modules.py +../jedi/__init__.py +../jedi/parsing.py +../jedi/docstrings.py +../jedi/_compatibility.py +../jedi/imports.py +../jedi/dynamic.py +../jedi/mixin/builtins.pym +../jedi/mixin/posix.pym +../jedi/mixin/_functools.pym +../jedi/mixin/_weakref.pym +../jedi/mixin/_sre.pym +../jedi/mixin/datetime.pym +../jedi/builtin.pyc +../jedi/evaluate.pyc +../jedi/debug.pyc +../jedi/helpers.pyc +../jedi/settings.pyc +../jedi/keywords.pyc +../jedi/api_classes.pyc +../jedi/api.pyc +../jedi/modules.pyc +../jedi/__init__.pyc +../jedi/parsing.pyc +../jedi/docstrings.pyc +../jedi/_compatibility.pyc +../jedi/imports.pyc +../jedi/dynamic.pyc +./ +SOURCES.txt +PKG-INFO +dependency_links.txt +top_level.txt diff --git a/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/top_level.txt b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/top_level.txt new file mode 100644 index 0000000..86c1cb1 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi-0.5b5.egg-info/top_level.txt @@ -0,0 +1 @@ +jedi diff --git a/common/.local/lib/python2.7/site-packages/jedi/__init__.py b/common/.local/lib/python2.7/site-packages/jedi/__init__.py new file mode 100644 index 0000000..9f8c369 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/__init__.py @@ -0,0 +1,16 @@ +import sys + +# python imports are hell sometimes. Especially the combination of relative +# imports and circular imports... Just avoid it: +sys.path.insert(0, __path__[0]) + +from .api import Script, NotFoundError, set_debug_function +from . import settings + +from . import api + +__doc__ = api.__doc__ + +del api + +sys.path.pop(0) diff --git a/common/.local/lib/python2.7/site-packages/jedi/_compatibility.py b/common/.local/lib/python2.7/site-packages/jedi/_compatibility.py new file mode 100644 index 0000000..d701526 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/_compatibility.py @@ -0,0 +1,169 @@ +""" +This is a compatibility module, to make it possible to use jedi also with older +python versions. +""" +import sys + +is_py3k = sys.hexversion >= 0x03000000 + +is_py25 = sys.hexversion < 0x02060000 + +# next was defined in python 2.6, in python 3 obj.next won't be possible +# anymore +try: + next = next +except NameError: + _raiseStopIteration = object() + + def next(iterator, default=_raiseStopIteration): + if not hasattr(iterator, 'next'): + raise TypeError("not an iterator") + try: + return iterator.next() + except StopIteration: + if default is _raiseStopIteration: + raise + else: + return default + +# ast module was defined in python 2.6 +try: + from ast import literal_eval +except ImportError: + literal_eval = eval + + +# properties in 2.5 +try: + property.setter +except AttributeError: + class property(property): + def __init__(self, fget, *args, **kwargs): + self.__doc__ = fget.__doc__ + super(property, self).__init__(fget, *args, **kwargs) + + def setter(self, fset): + cls_ns = sys._getframe(1).f_locals + for k, v in cls_ns.iteritems(): + if v == self: + propname = k + break + cls_ns[propname] = property(self.fget, fset, + self.fdel, self.__doc__) + return cls_ns[propname] +else: + property = property + +# unicode function +try: + unicode = unicode +except NameError: + unicode = str + +if is_py3k: + utf8 = lambda s: s +else: + utf8 = lambda s: s.decode('utf-8') + +utf8.__doc__ = """ +Decode a raw string into unicode object. Do nothing in Python 3. +""" + +# exec function +if is_py3k: + def exec_function(source, global_map): + exec(source, global_map) +else: + eval(compile("""def exec_function(source, global_map): + exec source in global_map """, 'blub', 'exec')) + +# StringIO (Python 2.5 has no io module), so use io only for py3k +try: + from StringIO import StringIO +except ImportError: + from io import StringIO + +# hasattr function used because python +if is_py3k: + hasattr = hasattr +else: + def hasattr(obj, name): + try: + getattr(obj, name) + return True + except AttributeError: + return False + + +class Python3Method(object): + def __init__(self, func): + self.func = func + + def __get__(self, obj, objtype): + if obj is None: + return lambda *args, **kwargs: self.func(*args, **kwargs) + else: + return lambda *args, **kwargs: self.func(obj, *args, **kwargs) + +try: + # the python3 way + from functools import reduce +except ImportError: + reduce = reduce + + +def use_metaclass(meta, *bases): + """ Create a class with a metaclass. """ + if not bases: + bases = (object,) + return meta("HackClass", bases, {}) + +try: + from inspect import cleandoc +except ImportError: + # python 2.5 doesn't have this method + import string + + def cleandoc(doc): + """Clean up indentation from docstrings. + + Any whitespace that can be uniformly removed from the second line + onwards is removed.""" + try: + lines = string.split(string.expandtabs(doc), '\n') + except UnicodeError: + return None + else: + # Find minimum indentation of any non-blank lines after first line. + margin = sys.maxint + for line in lines[1:]: + content = len(string.lstrip(line)) + if content: + indent = len(line) - content + margin = min(margin, indent) + # Remove indentation. + if lines: + lines[0] = lines[0].lstrip() + if margin < sys.maxint: + for i in range(1, len(lines)): + lines[i] = lines[i][margin:] + # Remove any trailing or leading blank lines. + while lines and not lines[-1]: + lines.pop() + while lines and not lines[0]: + lines.pop(0) + return string.join(lines, '\n') + +if is_py25: + # adds the `itertools.chain.from_iterable` constructor + import itertools + + class chain(itertools.chain): + @staticmethod + def from_iterable(iterables): + # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F + for it in iterables: + for element in it: + yield element + itertools.chain = chain + del chain diff --git a/common/.local/lib/python2.7/site-packages/jedi/api.py b/common/.local/lib/python2.7/site-packages/jedi/api.py new file mode 100644 index 0000000..248991b --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/api.py @@ -0,0 +1,457 @@ +""" +Jedi is an autocompletion library for Python. It offers additonal +services such as goto / get_definition / pydoc support / +get_in_function_call / related names. + +To give you a simple exmple how you can use the jedi library, +here is an exmple for the autocompletion feature: + +>>> import jedi +>>> source = '''import json; json.l''' +>>> script = jedi.Script(source, 1, 19, '') +>>> script + +>>> completions = script.complete() +>>> completions +[, ] +>>> completions[0].complete +'oad' +>>> completions[0].word +'load' + +As you see Jedi is pretty simple and allows you to concentrate +writing a good text editor, while still having very good IDE features +for Python. +""" +from __future__ import with_statement +__all__ = ['Script', 'NotFoundError', 'set_debug_function'] + +import re + +import parsing +import dynamic +import imports +import evaluate +import modules +import debug +import settings +import keywords +import helpers +import builtin +import api_classes + +from _compatibility import next, unicode + + +class NotFoundError(Exception): + """ A custom error to avoid catching the wrong exceptions """ + pass + + +class Script(object): + """ + A Script is the base for a completion, goto or whatever call. + + :param source: The source code of the current file + :type source: string + :param line: The line to complete in. + :type line: int + :param col: The column to complete in. + :type col: int + :param source_path: The path in the os, the current module is in. + :type source_path: string or None + :param source_encoding: encoding for decoding `source`, when it + is not a `unicode` object. + :type source_encoding: string + """ + def __init__(self, source, line, column, source_path, + source_encoding='utf-8'): + debug.reset_time() + try: + source = unicode(source, source_encoding, 'replace') + # Use 'replace' over 'ignore' to hold code structure. + except TypeError: # `source` is already a unicode object + pass + self.pos = line, column + self.module = modules.ModuleWithCursor(source_path, source=source, + position=self.pos) + self.source_path = source_path + debug.speed('init') + + @property + def parser(self): + """ The lazy parser """ + return self.module.parser + + def complete(self): + """ + An auto completer for python files. + + :return: list of Completion objects, sorted by name and __ comes last. + :rtype: list + """ + def follow_imports_if_possible(name): + # TODO remove this, or move to another place (not used) + par = name.parent + if isinstance(par, parsing.Import) and not \ + isinstance(self.parser.user_stmt, parsing.Import): + new = imports.ImportPath(par).follow(is_goto=True) + # Only remove the old entry if a new one has been found. + #print par, new, par.parent + if new: + try: + return new + except AttributeError: # .name undefined + pass + return [name] + + + debug.speed('complete start') + path = self.module.get_path_until_cursor() + path, dot, like = self._get_completion_parts(path) + + try: + scopes = list(self._prepare_goto(path, True)) + except NotFoundError: + scopes = [] + scope_generator = evaluate.get_names_for_scope( + self.parser.user_scope, self.pos) + completions = [] + for scope, name_list in scope_generator: + for c in name_list: + completions.append((c, scope)) + else: + completions = [] + debug.dbg('possible scopes', scopes) + for s in scopes: + if s.isinstance(evaluate.Function): + names = s.get_magic_method_names() + else: + if isinstance(s, imports.ImportPath): + if like == 'import': + l = self.module.get_line(self.pos[0])[:self.pos[1]] + if not l.endswith('import import'): + continue + names = s.get_defined_names(on_import_stmt=True) + else: + names = s.get_defined_names() + + for c in names: + completions.append((c, s)) + + if not dot: # named_params have no dots + call_def = self.get_in_function_call() + if call_def: + if not call_def.module.is_builtin(): + for p in call_def.params: + completions.append((p.get_name(), p)) + + # Do the completion if there is no path before and no import stmt. + if (not scopes or not isinstance(scopes[0], imports.ImportPath)) \ + and not path: + # add keywords + bs = builtin.Builtin.scope + completions += ((k, bs) for k in keywords.get_keywords( + all=True)) + + needs_dot = not dot and path + + comps = [] + for c, s in set(completions): + n = c.names[-1] + if settings.case_insensitive_completion \ + and n.lower().startswith(like.lower()) \ + or n.startswith(like): + if not evaluate.filter_private_variable(s, + self.parser.user_stmt, n): + new = api_classes.Completion(c, needs_dot, + len(like), s) + comps.append(new) + + debug.speed('complete end') + + return sorted(comps, key=lambda x: (x.word.startswith('__'), + x.word.startswith('_'), + x.word.lower())) + + def _prepare_goto(self, goto_path, is_like_search=False): + """ Base for complete, goto and get_definition. Basically it returns + the resolved scopes under cursor. """ + debug.dbg('start: %s in %s' % (goto_path, self.parser.scope)) + + user_stmt = self.parser.user_stmt + debug.speed('parsed') + if not user_stmt and len(goto_path.split('\n')) > 1: + # If the user_stmt is not defined and the goto_path is multi line, + # something's strange. Most probably the backwards tokenizer + # matched to much. + return [] + + if isinstance(user_stmt, parsing.Import): + scopes = [self._get_on_import_stmt(is_like_search)[0]] + else: + # just parse one statement, take it and evaluate it + stmt = self._get_under_cursor_stmt(goto_path) + scopes = evaluate.follow_statement(stmt) + return scopes + + def _get_under_cursor_stmt(self, cursor_txt): + r = parsing.PyFuzzyParser(cursor_txt, self.source_path, no_docstr=True) + try: + stmt = r.module.statements[0] + except IndexError: + raise NotFoundError() + stmt.start_pos = self.pos + stmt.parent = self.parser.user_scope + return stmt + + def get_definition(self): + """ + Returns the definitions of a the path under the cursor. This is + not a goto function! This follows complicated paths and returns the + end, not the first definition. + The big difference of goto and get_definition is that goto doesn't + follow imports and statements. + Multiple objects may be returned, because Python itself is a dynamic + language, which means depending on an option you can have two different + versions of a function. + + :return: list of Definition objects, which are basically scopes. + :rtype: list + """ + def resolve_import_paths(scopes): + for s in scopes.copy(): + if isinstance(s, imports.ImportPath): + scopes.remove(s) + scopes.update(resolve_import_paths(set(s.follow()))) + return scopes + + goto_path = self.module.get_path_under_cursor() + + context = self.module.get_context() + if next(context) in ('class', 'def'): + scopes = set([self.module.parser.user_scope]) + elif not goto_path: + op = self.module.get_operator_under_cursor() + scopes = set([keywords.get_operator(op, self.pos)] if op else []) + else: + scopes = set(self._prepare_goto(goto_path)) + + scopes = resolve_import_paths(scopes) + + # add keywords + scopes |= keywords.get_keywords(string=goto_path, pos=self.pos) + + d = set([api_classes.Definition(s) for s in scopes + if not isinstance(s, imports.ImportPath._GlobalNamespace)]) + return sorted(d, key=lambda x: (x.module_path, x.start_pos)) + + def goto(self): + """ + Returns the first definition found by goto. This means: It doesn't + follow imports and statements. + Multiple objects may be returned, because Python itself is a dynamic + language, which means depending on an option you can have two different + versions of a function. + + :return: list of Definition objects, which are basically scopes. + """ + d = [api_classes.Definition(d) for d in set(self._goto()[0])] + return sorted(d, key=lambda x: (x.module_path, x.start_pos)) + + def _goto(self, add_import_name=False): + """ + Used for goto and related_names. + :param add_import_name: TODO add description + """ + def follow_inexistent_imports(defs): + """ Imports can be generated, e.g. following + `multiprocessing.dummy` generates an import dummy in the + multiprocessing module. The Import doesn't exist -> follow. + """ + definitions = set(defs) + for d in defs: + if isinstance(d.parent, parsing.Import) \ + and d.start_pos == (0, 0): + i = imports.ImportPath(d.parent).follow(is_goto=True) + definitions.remove(d) + definitions |= follow_inexistent_imports(i) + return definitions + + goto_path = self.module.get_path_under_cursor() + context = self.module.get_context() + if next(context) in ('class', 'def'): + user_scope = self.parser.user_scope + definitions = set([user_scope.name]) + search_name = str(user_scope.name) + elif isinstance(self.parser.user_stmt, parsing.Import): + s, name_part = self._get_on_import_stmt() + try: + definitions = [s.follow(is_goto=True)[0]] + except IndexError: + definitions = [] + search_name = str(name_part) + + if add_import_name: + import_name = self.parser.user_stmt.get_defined_names() + # imports have only one name + if name_part == import_name[0].names[-1]: + definitions.append(import_name[0]) + else: + stmt = self._get_under_cursor_stmt(goto_path) + defs, search_name = evaluate.goto(stmt) + definitions = follow_inexistent_imports(defs) + return definitions, search_name + + def related_names(self, additional_module_paths=[]): + """ + Returns `dynamic.RelatedName` objects, which contain all names, that + are defined by the same variable, function, class or import. + This function can be used either to show all the usages of a variable + or for renaming purposes. + + TODO implement additional_module_paths + """ + user_stmt = self.parser.user_stmt + definitions, search_name = self._goto(add_import_name=True) + if isinstance(user_stmt, parsing.Statement) \ + and self.pos < user_stmt.get_assignment_calls().start_pos: + # the search_name might be before `=` + definitions = [v for v in user_stmt.set_vars + if str(v) == search_name] + if not isinstance(user_stmt, parsing.Import): + # import case is looked at with add_import_name option + definitions = dynamic.related_name_add_import_modules(definitions, + search_name) + + module = set([d.get_parent_until() for d in definitions]) + module.add(self.parser.module) + names = dynamic.related_names(definitions, search_name, module) + + for d in set(definitions): + if isinstance(d, parsing.Module): + names.append(api_classes.RelatedName(d, d)) + else: + names.append(api_classes.RelatedName(d.names[0], d)) + + return sorted(set(names), key=lambda x: (x.module_path, x.start_pos), + reverse=True) + + def get_in_function_call(self): + """ + Return the function, that the cursor is in, e.g.: + >>> isinstance(| # | <-- cursor is here + + This would return the `isinstance` function. In contrary: + >>> isinstance()| # | <-- cursor is here + + This would return `None`. + """ + def check_user_stmt(user_stmt): + if user_stmt is None \ + or not isinstance(user_stmt, parsing.Statement): + return None, 0 + ass = helpers.fast_parent_copy(user_stmt.get_assignment_calls()) + + call, index, stop = helpers.scan_array_for_pos(ass, self.pos) + return call, index + + def check_cache(): + """ Do the parsing with a part parser, therefore reduce ressource + costs. + TODO this is not working with multi-line docstrings, improve. + """ + if self.source_path is None: + return None, 0 + + try: + timestamp, parser = builtin.CachedModule.cache[ + self.source_path] + except KeyError: + return None, 0 + part_parser = self.module.get_part_parser() + user_stmt = part_parser.user_stmt + call, index = check_user_stmt(user_stmt) + if call: + old_stmt = parser.module.get_statement_for_position(self.pos) + if old_stmt is None: + return None, 0 + old_call, old_index = check_user_stmt(old_stmt) + if old_call: + # compare repr because that should definitely be the same. + # Otherwise the whole thing is out of sync. + if repr(old_call) == repr(call): + # return the index of the part_parser + return old_call, index + return None, 0 + else: + raise NotFoundError() + + debug.speed('func_call start') + try: + call, index = check_cache() + except NotFoundError: + return None + debug.speed('func_call parsed') + + if call is None: + # This is a backup, if the above is not successful. + user_stmt = self.parser.user_stmt + call, index = check_user_stmt(user_stmt) + if call is None: + return None + + debug.speed('func_call user_stmt') + with helpers.scale_speed_settings(settings.scale_get_in_function_call): + origins = evaluate.follow_call(call) + debug.speed('func_call followed') + + if len(origins) == 0: + return None + # just take entry zero, because we need just one. + executable = origins[0] + + return api_classes.CallDef(executable, index, call) + + def _get_on_import_stmt(self, is_like_search=False): + """ Resolve the user statement, if it is an import. Only resolve the + parts until the user position. """ + user_stmt = self.parser.user_stmt + import_names = user_stmt.get_all_import_names() + kill_count = -1 + cur_name_part = None + for i in import_names: + if user_stmt.alias == i: + continue + for name_part in i.names: + if name_part.end_pos >= self.pos: + if not cur_name_part: + cur_name_part = name_part + kill_count += 1 + + i = imports.ImportPath(user_stmt, is_like_search, + kill_count=kill_count, direct_resolve=True) + return i, cur_name_part + + def _get_completion_parts(self, path): + """ + Returns the parts for the completion + :return: tuple - (path, dot, like) + """ + match = re.match(r'^(.*?)(\.|)(\w?[\w\d]*)$', path, flags=re.S) + return match.groups() + + def __del__(self): + evaluate.clear_caches() + + +def set_debug_function(func_cb=debug.print_to_stdout, warnings=True, + notices=True, speed=True): + """ + You can define a callback debug function to get all the debug messages. + :param func_cb: The callback function for debug messages, with n params. + """ + debug.debug_function = func_cb + debug.enable_warning = warnings + debug.enable_notice = notices + debug.enable_speed = speed diff --git a/common/.local/lib/python2.7/site-packages/jedi/api_classes.py b/common/.local/lib/python2.7/site-packages/jedi/api_classes.py new file mode 100644 index 0000000..367615a --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/api_classes.py @@ -0,0 +1,311 @@ +""" The classes returned by the api """ + +import re +import os + +import settings +import evaluate +import imports +import parsing +import keywords + + +class BaseDefinition(object): + _mapping = {'posixpath': 'os.path', + 'riscospath': 'os.path', + 'ntpath': 'os.path', + 'os2emxpath': 'os.path', + 'macpath': 'os.path', + 'genericpath': 'os.path', + '_io': 'io', + '__builtin__': '', + 'builtins': '', + } + + _tuple_mapping = dict((tuple(k.split('.')), v) for (k, v) in { + 'argparse._ActionsContainer': 'argparse.ArgumentParser', + '_sre.SRE_Match': 're.MatchObject', + '_sre.SRE_Pattern': 're.RegexObject', + }.items()) + + def __init__(self, definition, start_pos): + self.start_pos = start_pos + self.definition = definition + self.is_keyword = isinstance(definition, keywords.Keyword) + + # generate a path to the definition + self.module_path = str(definition.get_parent_until().path) + + @property + def type(self): + # generate the type + stripped = self.definition + if isinstance(self.definition, evaluate.InstanceElement): + stripped = self.definition.var + return type(stripped).__name__ + + @property + def path(self): + path = [] + if not isinstance(self.definition, keywords.Keyword): + par = self.definition + while par is not None: + try: + path.insert(0, par.name) + except AttributeError: + pass + par = par.parent + return path + + @property + def module_name(self): + path = self.module_path + sep = os.path.sep + p = re.sub(r'^.*?([\w\d]+)(%s__init__)?.py$' % sep, r'\1', path) + return p + + def in_builtin_module(self): + return not self.module_path.endswith('.py') + + @property + def line_nr(self): + return self.start_pos[0] + + @property + def column(self): + return self.start_pos[1] + + @property + def doc(self): + """ Return a document string for this completion object. """ + try: + return self.definition.doc + except AttributeError: + return self.raw_doc + + @property + def raw_doc(self): + """ Returns the raw docstring `__doc__` for any object """ + try: + return str(self.definition.docstr) + except AttributeError: + return '' + + @property + def description(self): + return str(self.definition) + + @property + def full_name(self): + """ + Returns the path to a certain class/function, see #61. + """ + path = [str(p) for p in self.path] + # TODO add further checks, the mapping should only occur on stdlib. + try: + path[0] = self._mapping[path[0]] + except KeyError: + pass + for key, repl in self._tuple_mapping.items(): + if tuple(path[:len(key)]) == key: + path = [repl] + path[len(key):] + + return '.'.join(path if path[0] else path[1:]) + + def __repr__(self): + return "<%s %s>" % (type(self).__name__, self.description) + + +class Completion(BaseDefinition): + """ `Completion` objects are returned from `Script.complete`. Providing + some useful functions for IDE's. """ + def __init__(self, name, needs_dot, like_name_length, base): + super(Completion, self).__init__(name.parent, name.start_pos) + + self.name = name + self.needs_dot = needs_dot + self.like_name_length = like_name_length + self.base = base + + self._followed_definitions = None + + @property + def complete(self): + """ Delievers the rest of the word, e.g. completing `isinstance` + >>> isinstan + + would return the string 'ce'. It also adds additional stuff, depending + on your `settings.py` + """ + dot = '.' if self.needs_dot else '' + append = '' + if settings.add_bracket_after_function \ + and self.type == 'Function': + append = '(' + + if settings.add_dot_after_module: + if isinstance(self.base, parsing.Module): + append += '.' + if isinstance(self.base, parsing.Param): + append += '=' + return dot + self.name.names[-1][self.like_name_length:] + append + + @property + def word(self): + """ In contrary to `complete` returns the whole word, e.g. + >>> isinstan + + would return 'isinstance'. + """ + return str(self.name.names[-1]) + + @property + def description(self): + """ Provides a description of the completion object + TODO return value is just __repr__ of some objects, improve! """ + parent = self.name.parent + if parent is None: + return '' + t = self.type + if t == 'Statement' or t == 'Import': + desc = self.definition.get_code(False) + else: + desc = '.'.join(str(p) for p in self.path) + + line_nr = '' if self.in_builtin_module else '@%s' % self.line_nr + return '%s: %s%s' % (t, desc, line_nr) + + def follow_definition(self): + """ Returns you the original definitions. I strongly recommend not + using it for your completions, because it might slow down Jedi. If you + want to read only a few objects (<=20). I think it might be useful, + especially to get the original docstrings. + The basic problem of this function is that it follows all results. This + means with 1000 completions (e.g. numpy), it's just PITA slow. + """ + if self._followed_definitions is None: + if self.definition.isinstance(parsing.Statement): + defs = evaluate.follow_statement(self.definition) + elif self.definition.isinstance(parsing.Import): + defs = imports.strip_imports([self.definition]) + else: + return [self] + + self._followed_definitions = \ + [BaseDefinition(d, d.start_pos) for d in defs] + evaluate.clear_caches() + + return self._followed_definitions + + def __repr__(self): + return '<%s: %s>' % (type(self).__name__, self.name) + + +class Definition(BaseDefinition): + """ These are the objects returned by either `Script.goto` or + `Script.get_definition`. """ + def __init__(self, definition): + super(Definition, self).__init__(definition, definition.start_pos) + + @property + def description(self): + """ A description of the Definition object, which is heavily used in + testing. e.g. for `isinstance` it returns 'def isinstance' """ + d = self.definition + if isinstance(d, evaluate.InstanceElement): + d = d.var + if isinstance(d, evaluate.parsing.Name): + d = d.parent + + if isinstance(d, evaluate.Array): + d = 'class ' + d.type + elif isinstance(d, (parsing.Class, evaluate.Class, evaluate.Instance)): + d = 'class ' + str(d.name) + elif isinstance(d, (evaluate.Function, evaluate.parsing.Function)): + d = 'def ' + str(d.name) + elif isinstance(d, evaluate.parsing.Module): + # only show module name + d = 'module %s' % self.module_name + elif self.is_keyword: + d = 'keyword %s' % d.name + else: + d = d.get_code().replace('\n', '') + return d + + @property + def desc_with_module(self): + """ In addition to the Definition, it also returns the module. Don't + use it yet, its behaviour may change. If you really need it, talk to me + TODO add full path. This function is should return a + module.class.function path. """ + if self.module_path.endswith('.py') \ + and not isinstance(self.definition, parsing.Module): + position = '@%s' % (self.line_nr) + else: + # is a builtin or module + position = '' + return "%s:%s%s" % (self.module_name, self.description, position) + + +class RelatedName(BaseDefinition): + def __init__(self, name_part, scope): + super(RelatedName, self).__init__(scope, name_part.start_pos) + self.name_part = name_part + self.text = str(name_part) + self.end_pos = name_part.end_pos + + @property + def description(self): + return "%s@%s,%s" % (self.text, self.start_pos[0], self.start_pos[1]) + + def __eq__(self, other): + return self.start_pos == other.start_pos \ + and self.module_path == other.module_path + + def __hash__(self): + return hash((self.start_pos, self.module_path)) + + +class CallDef(object): + """ `CallDef` objects is the return value of `Script.get_in_function_call`. + It knows what functions you are currently in. e.g. `isinstance(` would + return the `isinstance` function. without `(` it would return nothing.""" + def __init__(self, executable, index, call): + self.executable = executable + self.index = index + self.call = call + + @property + def params(self): + if self.executable.isinstance(evaluate.Function): + if isinstance(self.executable, evaluate.InstanceElement): + return self.executable.params[1:] + return self.executable.params + else: + try: + sub = self.executable.get_subscope_by_name('__init__') + return sub.params[1:] # ignore self + except KeyError: + return [] + + @property + def bracket_start(self): + """ The indent of the bracket that is responsible for the last function + call. """ + c = self.call + while c.next is not None: + c = c.next + return c.name.end_pos + + @property + def call_name(self): + """ The name (e.g. 'isinstance') as a string. """ + return str(self.executable.name) + + @property + def module(self): + return self.executable.get_parent_until() + + def __repr__(self): + return '<%s: %s index %s>' % (type(self).__name__, self.executable, + self.index) diff --git a/common/.local/lib/python2.7/site-packages/jedi/builtin.py b/common/.local/lib/python2.7/site-packages/jedi/builtin.py new file mode 100644 index 0000000..da4fc56 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/builtin.py @@ -0,0 +1,472 @@ +from __future__ import with_statement +from _compatibility import exec_function, is_py3k + +import re +import sys +import os +if is_py3k: + import io +import types +import inspect + +import debug +import parsing +import imports +import evaluate + + +def get_sys_path(): + def check_virtual_env(sys_path): + """ Add virtualenv's site-packages to the `sys.path`.""" + venv = os.getenv('VIRTUAL_ENV') + if not venv: + return + venv = os.path.abspath(venv) + p = os.path.join( + venv, 'lib', 'python%d.%d' % sys.version_info[:2], 'site-packages') + sys_path.insert(0, p) + + p = sys.path[1:] + check_virtual_env(p) + return p + + +class CachedModule(object): + """ + The base type for all modules, which is not to be confused with + `parsing.Module`. Caching happens here. + """ + cache = {} + + def __init__(self, path=None, name=None): + self.path = path and os.path.abspath(path) + self.name = name + self._parser = None + + @property + def parser(self): + """ get the parser lazy """ + if not self._parser: + try: + timestamp, parser = self.cache[self.path or self.name] + if not self.path or os.path.getmtime(self.path) <= timestamp: + self._parser = parser + else: + # In case there is already a module cached and this module + # has to be reparsed, we also need to invalidate the import + # caches. + imports.invalidate_star_import_cache(parser.module) + raise KeyError() + except KeyError: + self._load_module() + return self._parser + + def _get_source(self): + raise NotImplementedError() + + def _load_module(self): + source = self._get_source() + self._parser = parsing.PyFuzzyParser(source, self.path or self.name) + p_time = None if not self.path else os.path.getmtime(self.path) + + if self.path or self.name: + self.cache[self.path or self.name] = p_time, self._parser + + +class Parser(CachedModule): + """ + This module is a parser for all builtin modules, which are programmed in + C/C++. It should also work on third party modules. + It can be instantiated with either a path or a name of the module. The path + is important for third party modules. + + :param name: The name of the module. + :param path: The path of the module. + :param sys_path: The sys.path, which is can be customizable. + """ + + map_types = { + 'floating point number': '0.0', + 'string': '""', + 'str': '""', + 'character': '"a"', + 'integer': '0', + 'int': '0', + 'dictionary': '{}', + 'list': '[]', + 'file object': 'file("")', + # TODO things like dbg: ('not working', 'tuple of integers') + } + + if is_py3k: + map_types['file object'] = 'import io; return io.TextIOWrapper()' + + module_cache = {} + + def __init__(self, path=None, name=None, sys_path=None): + if sys_path is None: + sys_path = get_sys_path() + if not name: + name = os.path.basename(path) + name = name.rpartition('.')[0] # cut file type (normally .so) + super(Parser, self).__init__(path=path, name=name) + + self.sys_path = list(sys_path) + self._module = None + + @property + def module(self): + def load_module(name, path): + if path: + self.sys_path.insert(0, path) + + temp, sys.path = sys.path, self.sys_path + content = {} + try: + exec_function('import %s as module' % name, content) + self._module = content['module'] + except AttributeError: + # use sys.modules, because you cannot access some modules + # directly. -> #59 + self._module = sys.modules[name] + sys.path = temp + + if path: + self.sys_path.pop(0) + + # module might already be defined + if not self._module: + path = self.path + name = self.name + if self.path: + + dot_path = [] + p = self.path + # search for the builtin with the correct path + while p and p not in sys.path: + p, sep, mod = p.rpartition(os.path.sep) + dot_path.append(mod.partition('.')[0]) + if p: + name = ".".join(reversed(dot_path)) + path = p + else: + path = os.path.dirname(self.path) + + load_module(name, path) + return self._module + + def _get_source(self): + """ Override this abstract method """ + return _generate_code(self.module, self._load_mixins()) + + def _load_mixins(self): + """ + Load functions that are mixed in to the standard library. + E.g. builtins are written in C (binaries), but my autocompletion only + understands Python code. By mixing in Python code, the autocompletion + should work much better for builtins. + """ + regex = r'^(def|class)\s+([\w\d]+)' + + def process_code(code, depth=0): + funcs = {} + matches = list(re.finditer(regex, code, re.MULTILINE)) + positions = [m.start() for m in matches] + for i, pos in enumerate(positions): + try: + code_block = code[pos:positions[i + 1]] + except IndexError: + code_block = code[pos:len(code)] + structure_name = matches[i].group(1) + name = matches[i].group(2) + if structure_name == 'def': + funcs[name] = code_block + elif structure_name == 'class': + if depth > 0: + raise NotImplementedError() + + # remove class line + c = re.sub(r'^[^\n]+', '', code_block) + # remove whitespace + c = re.compile(r'^[ ]{4}', re.MULTILINE).sub('', c) + + funcs[name] = process_code(c) + else: + raise NotImplementedError() + return funcs + + try: + name = self.name + if name == '__builtin__' and not is_py3k: + name = 'builtins' + path = os.path.dirname(os.path.abspath(__file__)) + with open(os.path.sep.join([path, 'mixin', name]) + '.pym') as f: + s = f.read() + except IOError: + return {} + else: + mixin_dct = process_code(s) + if is_py3k and self.name == Builtin.name: + # in the case of Py3k xrange is now range + mixin_dct['range'] = mixin_dct['xrange'] + return mixin_dct + + +def _generate_code(scope, mixin_funcs={}, depth=0): + """ + Generate a string, which uses python syntax as an input to the + PyFuzzyParser. + """ + def get_doc(obj, indent=False): + doc = inspect.getdoc(obj) + if doc: + doc = ('r"""\n%s\n"""\n' % doc) + if indent: + doc = parsing.indent_block(doc) + return doc + return '' + + def is_in_base_classes(cls, name, comparison): + """ Base classes may contain the exact same object """ + if name in mixin_funcs: + return False + try: + mro = cls.mro() + except TypeError: + # this happens, if cls == type + return False + for base in mro[1:]: + try: + attr = getattr(base, name) + except AttributeError: + continue + if attr == comparison: + return True + return False + + def get_scope_objects(names): + """ + Looks for the names defined with dir() in an objects and divides + them into different object types. + """ + classes = {} + funcs = {} + stmts = {} + members = {} + for n in names: + try: + # this has a builtin_function_or_method + exe = getattr(scope, n) + except AttributeError: + # happens e.g. in properties of + # PyQt4.QtGui.QStyleOptionComboBox.currentText + # -> just set it to None + members[n] = None + else: + if inspect.isclass(scope): + if is_in_base_classes(scope, n, exe): + continue + if inspect.isbuiltin(exe) or inspect.ismethod(exe) \ + or inspect.ismethoddescriptor(exe): + funcs[n] = exe + elif inspect.isclass(exe): + classes[n] = exe + elif inspect.ismemberdescriptor(exe): + members[n] = exe + else: + stmts[n] = exe + return classes, funcs, stmts, members + + code = '' + if inspect.ismodule(scope): # generate comment where the code's from. + try: + path = scope.__file__ + except AttributeError: + path = '?' + code += '# Generated module %s from %s\n' % (scope.__name__, path) + + code += get_doc(scope) + + names = set(dir(scope)) - set(['__file__', '__name__', '__doc__', + '__path__', '__package__']) \ + | set(['mro']) + + classes, funcs, stmts, members = get_scope_objects(names) + + # classes + for name, cl in classes.items(): + bases = (c.__name__ for c in cl.__bases__) + code += 'class %s(%s):\n' % (name, ','.join(bases)) + if depth == 0: + try: + mixin = mixin_funcs[name] + except KeyError: + mixin = {} + cl_code = _generate_code(cl, mixin, depth + 1) + code += parsing.indent_block(cl_code) + code += '\n' + + # functions + for name, func in funcs.items(): + params, ret = parse_function_doc(func) + if depth > 0: + params = 'self, ' + params + doc_str = get_doc(func, indent=True) + try: + mixin = mixin_funcs[name] + except KeyError: + # normal code generation + code += 'def %s(%s):\n' % (name, params) + code += doc_str + code += parsing.indent_block('%s\n\n' % ret) + else: + # generation of code with mixins + # the parser only supports basic functions with a newline after + # the double dots + # find doc_str place + pos = re.search(r'\):\s*\n', mixin).end() + if pos is None: + raise Exception("Builtin function not parsed correctly") + code += mixin[:pos] + doc_str + mixin[pos:] + + # class members (functions) properties? + for name, func in members.items(): + # recursion problem in properties TODO remove + if name in ['fget', 'fset', 'fdel']: + continue + ret = 'pass' + code += '@property\ndef %s(self):\n' % (name) + code += parsing.indent_block(get_doc(func) + '%s\n\n' % ret) + + # variables + for name, value in stmts.items(): + if is_py3k: + file_type = io.TextIOWrapper + else: + file_type = types.FileType + if type(value) == file_type: + value = 'open()' + elif name == 'None': + value = '' + elif type(value).__name__ in ['int', 'bool', 'float', + 'dict', 'list', 'tuple']: + value = repr(value) + else: + # get the type, if the type is not simple. + mod = type(value).__module__ + value = type(value).__name__ + '()' + if mod != '__builtin__': + value = '%s.%s' % (mod, value) + code += '%s = %s\n' % (name, value) + + if depth == 0: + #with open('writeout.py', 'w') as f: + # f.write(code) + #import sys + #sys.stdout.write(code) + #exit() + pass + return code + + +def parse_function_doc(func): + """ + Takes a function and returns the params and return value as a tuple. + This is nothing more than a docstring parser. + """ + # TODO: things like utime(path, (atime, mtime)) and a(b [, b]) -> None + doc = inspect.getdoc(func) + + # get full string, parse round parentheses: def func(a, (b,c)) + try: + count = 0 + debug.dbg(func, func.__name__, doc) + start = doc.index('(') + for i, s in enumerate(doc[start:]): + if s == '(': + count += 1 + elif s == ')': + count -= 1 + if count == 0: + end = start + i + break + param_str = doc[start + 1:end] + + # remove square brackets, that show an optional param ( = None) + def change_options(m): + args = m.group(1).split(',') + for i, a in enumerate(args): + if a and '=' not in a: + args[i] += '=None' + return ','.join(args) + while True: + param_str, changes = re.subn(r' ?\[([^\[\]]+)\]', + change_options, param_str) + if changes == 0: + break + except (ValueError, AttributeError): + debug.dbg('no brackets found - no param') + end = 0 + param_str = '' + + param_str = param_str.replace('-', '_') # see: isinstance.__doc__ + + if doc is not None: + r = re.search('-[>-]* ', doc[end:end + 7]) + if doc is None or r is None: + ret = 'pass' + else: + index = end + r.end() + # get result type, which can contain newlines + pattern = re.compile(r'(,\n|[^\n-])+') + ret_str = pattern.match(doc, index).group(0).strip() + # New object -> object() + ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str) + + ret = Parser.map_types.get(ret_str, ret_str) + if ret == ret_str and ret not in ['None', 'object', 'tuple', 'set']: + debug.dbg('not working', ret_str) + if ret != 'pass': + ret = ('return ' if 'return' not in ret else '') + ret + return param_str, ret + + +class Builtin(object): + """ The builtin scope / module """ + # Python 3 compatibility + if is_py3k: + name = 'builtins' + else: + name = '__builtin__' + + _builtin = None + + @property + def builtin(self): + if self._builtin is None: + self._builtin = Parser(name=self.name) + return self._builtin + + @property + def scope(self): + return self.builtin.parser.module + + @property + def magic_function_scope(self): + try: + return self._magic_function_scope + except AttributeError: + # depth = 1 because this is not a module + class Container(object): + FunctionType = types.FunctionType + source = _generate_code(Container, depth=0) + parser = parsing.PyFuzzyParser(source, None) + module = parser.module + module.parent = self.scope + typ = evaluate.follow_path(iter(['FunctionType']), module, module) + + s = self._magic_function_scope = typ.pop() + return s + + +Builtin = Builtin() diff --git a/common/.local/lib/python2.7/site-packages/jedi/debug.py b/common/.local/lib/python2.7/site-packages/jedi/debug.py new file mode 100644 index 0000000..321ffa8 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/debug.py @@ -0,0 +1,64 @@ +import inspect +import time + +try: + # Use colorama for nicer console output. + from colorama import Fore, init + init() +except ImportError: + class Fore(object): + RED = '' + GREEN = '' + YELLOW = '' + RESET = '' + +NOTICE = object() +WARNING = object() +SPEED = object() + +enable_speed = False +enable_warning = False +enable_notice = False + +# callback, interface: level, str +debug_function = None +ignored_modules = ['parsing', 'builtin', 'jedi.builtin', 'jedi.parsing'] + + +def reset_time(): + global start_time + start_time = time.time() + + +def dbg(*args): + """ Looks at the stack, to see if a debug message should be printed. """ + if debug_function and enable_notice: + frm = inspect.stack()[1] + mod = inspect.getmodule(frm[0]) + if not (mod.__name__ in ignored_modules): + debug_function(NOTICE, 'dbg: ' + ', '.join(str(a) for a in args)) + + +def warning(*args): + if debug_function and enable_warning: + debug_function(WARNING, 'warning: ' + ', '.join(str(a) for a in args)) + + +def speed(name): + if debug_function and enable_speed: + now = time.time() + debug_function(SPEED, 'speed: ' + '%s %s' % (name, now - start_time)) + + +def print_to_stdout(level, str_out): + """ The default debug function """ + if level == NOTICE: + col = Fore.GREEN + elif level == WARNING: + col = Fore.RED + else: + col = Fore.YELLOW + print(col + str_out + Fore.RESET) + + +#debug_function = print_to_stdout diff --git a/common/.local/lib/python2.7/site-packages/jedi/docstrings.py b/common/.local/lib/python2.7/site-packages/jedi/docstrings.py new file mode 100644 index 0000000..29bf0d2 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/docstrings.py @@ -0,0 +1,34 @@ +""" Processing of docstrings, which means parsing for types. """ + +import re + +import evaluate + + +#@evaluate.memoize_default() # TODO add +def follow_param(param): + func = param.parent_function + #print func, param, param.parent_function + param_str = search_param_in_docstr(func.docstr, str(param.get_name())) + + if param_str is not None: + scope = func.get_parent_until() + return evaluate.get_scopes_for_name(scope, param_str, + search_global=True) + return [] + + +def search_param_in_docstr(docstr, param_str): + lines = docstr.split('\n') + + # look at #40 to see definitions of those params + sphinx_comp = ':type %s:' % param_str + googley_comp = re.compile('\s*%s\s+\(([^()]+)\)' % re.escape(param_str)) + for l in lines: + if l.startswith(sphinx_comp): + return l.replace(sphinx_comp, '', 1).strip() + + r = re.match(googley_comp, l) + if r is not None: + return r.group(1) + return None diff --git a/common/.local/lib/python2.7/site-packages/jedi/dynamic.py b/common/.local/lib/python2.7/site-packages/jedi/dynamic.py new file mode 100644 index 0000000..2e77546 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/dynamic.py @@ -0,0 +1,507 @@ +""" +For dynamic completion. + +Sorry to everyone who is reading this code. Especially the array parts are +really cryptic and not understandable. It's just a hack, that turned out to be +working quite good. +""" +from __future__ import with_statement + +import os + +import parsing +import modules +import evaluate +import helpers +import settings +import debug +import builtin +import imports +import api_classes + +# This is something like the sys.path, but only for searching params. It means +# that this is the order in which Jedi searches params. +search_param_modules = ['.'] +search_param_cache = {} + + +def get_directory_modules_for_name(mods, name): + """ + Search a name in the directories of modules. + """ + def check_python_file(path): + try: + return builtin.CachedModule.cache[path][1].module + except KeyError: + try: + return check_fs(path) + except IOError: + return None + + def check_fs(path): + with open(path) as f: + source = f.read() + if name in source: + return modules.Module(path, source).parser.module + + # skip non python modules + mods = set(m for m in mods if m.path.endswith('.py')) + mod_paths = set() + for m in mods: + mod_paths.add(m.path) + yield m + + if settings.dynamic_params_for_other_modules: + paths = set(settings.additional_dynamic_modules) + for p in mod_paths: + d = os.path.dirname(p) + for entry in os.listdir(d): + if entry not in mod_paths: + if entry.endswith('.py'): + paths.add(d + os.path.sep + entry) + + for p in paths: + c = check_python_file(p) + if c is not None and c not in mods: + yield c + + +def search_param_memoize(func): + """ + Is only good for search params memoize, respectively the closure, + because it just caches the input, not the func, like normal memoize does. + """ + def wrapper(*args, **kwargs): + key = (args, frozenset(kwargs.items())) + if key in search_param_cache: + return search_param_cache[key] + else: + rv = func(*args, **kwargs) + search_param_cache[key] = rv + return rv + return wrapper + + +class ParamListener(object): + """ + This listener is used to get the params for a function. + """ + def __init__(self): + self.param_possibilities = [] + + def execute(self, params): + self.param_possibilities.append(params) + + +@evaluate.memoize_default([]) +def search_params(param): + """ + This is a dynamic search for params. If you try to complete a type: + >>> def func(foo): + >>> # here is the completion + >>> foo + >>> func(1) + >>> func("") + + It is not known what the type is, because it cannot be guessed with + recursive madness. Therefore one has to analyse the statements that are + calling the function, as well as analyzing the incoming params. + """ + if not settings.dynamic_params: + return [] + + def get_params_for_module(module): + """ + Returns the values of a param, or an empty array. + """ + @search_param_memoize + def get_posibilities(module, func_name): + try: + possible_stmts = module.used_names[func_name] + except KeyError: + return [] + + for stmt in possible_stmts: + if not isinstance(stmt, parsing.Import): + calls = _scan_array(stmt.get_assignment_calls(), func_name) + for c in calls: + # no execution means that params cannot be set + call_path = c.generate_call_path() + pos = c.start_pos + scope = stmt.parent + evaluate.follow_call_path(call_path, scope, pos) + return listener.param_possibilities + + result = [] + for params in get_posibilities(module, func_name): + for p in params: + if str(p) == param_name: + result += evaluate.follow_statement(p.parent) + return result + + func = param.get_parent_until(parsing.Function) + current_module = param.get_parent_until() + func_name = str(func.name) + if func_name == '__init__' and isinstance(func.parent, parsing.Class): + func_name = str(func.parent.name) + + # get the param name + if param.assignment_details: + arr = param.assignment_details[0][1] + else: + arr = param.get_assignment_calls() + offset = 1 if arr[0][0] in ['*', '**'] else 0 + param_name = str(arr[0][offset].name) + + # add the listener + listener = ParamListener() + func.listeners.add(listener) + + result = [] + # This is like backtracking: Get the first possible result. + for mod in get_directory_modules_for_name([current_module], func_name): + result = get_params_for_module(mod) + if result: + break + + # cleanup: remove the listener; important: should not stick. + func.listeners.remove(listener) + + return result + + +def check_array_additions(array): + """ Just a mapper function for the internal _check_array_additions """ + if array._array.type not in ['list', 'set']: + # TODO also check for dict updates + return [] + + is_list = array._array.type == 'list' + current_module = array._array.parent_stmt.get_parent_until() + res = _check_array_additions(array, current_module, is_list) + return res + + +def _scan_array(arr, search_name): + """ Returns the function Call that match search_name in an Array. """ + result = [] + for sub in arr: + for s in sub: + if isinstance(s, parsing.Array): + result += _scan_array(s, search_name) + elif isinstance(s, parsing.Call): + s_new = s + while s_new is not None: + n = s_new.name + if isinstance(n, parsing.Name) and search_name in n.names: + result.append(s) + + if s_new.execution is not None: + result += _scan_array(s_new.execution, search_name) + s_new = s_new.next + return result + + +counter = 0 +def dec(func): + """ TODO delete this """ + def wrapper(*args, **kwargs): + global counter + element = args[0] + if isinstance(element, evaluate.Array): + stmt = element._array.parent_stmt + else: + # must be instance + stmt = element.var_args.parent_stmt + print(' ' * counter + 'recursion,', stmt) + counter += 1 + res = func(*args, **kwargs) + counter -= 1 + #print ' '*counter + 'end,' + return res + return wrapper + + +#@dec +@evaluate.memoize_default([]) +def _check_array_additions(compare_array, module, is_list): + """ + Checks if a `parsing.Array` has "add" statements: + >>> a = [""] + >>> a.append(1) + """ + if not settings.dynamic_array_additions or module.is_builtin(): + return [] + + def check_calls(calls, add_name): + """ + Calls are processed here. The part before the call is searched and + compared with the original Array. + """ + result = [] + for c in calls: + call_path = list(c.generate_call_path()) + separate_index = call_path.index(add_name) + if add_name == call_path[-1] or separate_index == 0: + # this means that there is no execution -> [].append + # or the keyword is at the start -> append() + continue + backtrack_path = iter(call_path[:separate_index]) + + position = c.start_pos + scope = c.parent_stmt.parent + + found = evaluate.follow_call_path(backtrack_path, scope, position) + if not compare_array in found: + continue + + params = call_path[separate_index + 1] + if not params.values: + continue # no params: just ignore it + if add_name in ['append', 'add']: + result += evaluate.follow_call_list(params) + elif add_name in ['insert']: + try: + second_param = params[1] + except IndexError: + continue + else: + result += evaluate.follow_call_list([second_param]) + elif add_name in ['extend', 'update']: + iterators = evaluate.follow_call_list(params) + result += evaluate.get_iterator_types(iterators) + return result + + def get_execution_parent(element, *stop_classes): + """ Used to get an Instance/Execution parent """ + if isinstance(element, evaluate.Array): + stmt = element._array.parent_stmt + else: + # must be instance + stmt = element.var_args.parent_stmt + if isinstance(stmt, evaluate.InstanceElement): + stop_classes = list(stop_classes) + [evaluate.Function] + return stmt.get_parent_until(stop_classes) + + temp_param_add = settings.dynamic_params_for_other_modules + settings.dynamic_params_for_other_modules = False + + search_names = ['append', 'extend', 'insert'] if is_list else \ + ['add', 'update'] + comp_arr_parent = get_execution_parent(compare_array, evaluate.Execution) + possible_stmts = [] + res = [] + for n in search_names: + try: + possible_stmts += module.used_names[n] + except KeyError: + continue + for stmt in possible_stmts: + # Check if the original scope is an execution. If it is, one + # can search for the same statement, that is in the module + # dict. Executions are somewhat special in jedi, since they + # literally copy the contents of a function. + if isinstance(comp_arr_parent, evaluate.Execution): + stmt = comp_arr_parent. \ + get_statement_for_position(stmt.start_pos) + if stmt is None: + continue + # InstanceElements are special, because they don't get copied, + # but have this wrapper around them. + if isinstance(comp_arr_parent, evaluate.InstanceElement): + stmt = evaluate.InstanceElement(comp_arr_parent.instance, stmt) + + if evaluate.follow_statement.push_stmt(stmt): + # check recursion + continue + res += check_calls(_scan_array(stmt.get_assignment_calls(), n), n) + evaluate.follow_statement.pop_stmt() + # reset settings + settings.dynamic_params_for_other_modules = temp_param_add + return res + + +def check_array_instances(instance): + """ Used for set() and list() instances. """ + if not settings.dynamic_arrays_instances: + return instance.var_args + ai = ArrayInstance(instance) + return helpers.generate_param_array([ai], instance.var_args.parent_stmt) + + +class ArrayInstance(parsing.Base): + """ + Used for the usage of set() and list(). + This is definitely a hack, but a good one :-) + It makes it possible to use set/list conversions. + """ + def __init__(self, instance): + self.instance = instance + self.var_args = instance.var_args + + def iter_content(self): + """ + The index is here just ignored, because of all the appends, etc. + lists/sets are too complicated too handle that. + """ + items = [] + for array in evaluate.follow_call_list(self.var_args): + if isinstance(array, evaluate.Instance) and len(array.var_args): + temp = array.var_args[0][0] + if isinstance(temp, ArrayInstance): + # prevent recursions + # TODO compare Modules + if self.var_args.start_pos != temp.var_args.start_pos: + items += temp.iter_content() + else: + debug.warning('ArrayInstance recursion', self.var_args) + continue + items += evaluate.get_iterator_types([array]) + + if self.var_args.parent_stmt is None: + return [] # generated var_args should not be checked for arrays + + module = self.var_args.parent_stmt.get_parent_until() + is_list = str(self.instance.name) == 'list' + items += _check_array_additions(self.instance, module, is_list) + return items + + +def related_names(definitions, search_name, mods): + def check_call(call): + result = [] + follow = [] # There might be multiple search_name's in one call_path + call_path = list(call.generate_call_path()) + for i, name in enumerate(call_path): + # name is `parsing.NamePart`. + if name == search_name: + follow.append(call_path[:i + 1]) + + for f in follow: + follow_res, search = evaluate.goto(call.parent_stmt, f) + follow_res = related_name_add_import_modules(follow_res, search) + + #print follow_res, [d.parent for d in follow_res] + # compare to see if they match + if any(r in definitions for r in follow_res): + scope = call.parent_stmt + result.append(api_classes.RelatedName(search, scope)) + + return result + + if not definitions: + return set() + + def is_definition(arr): + try: + for a in arr: + assert len(a) == 1 + a = a[0] + if a.isinstance(parsing.Array): + assert is_definition(a) + elif a.isinstance(parsing.Call): + assert a.execution is None + return True + except AssertionError: + return False + + mods |= set([d.get_parent_until() for d in definitions]) + names = [] + for m in get_directory_modules_for_name(mods, search_name): + try: + stmts = m.used_names[search_name] + except KeyError: + continue + for stmt in stmts: + if isinstance(stmt, parsing.Import): + count = 0 + imps = [] + for i in stmt.get_all_import_names(): + for name_part in i.names: + count += 1 + if name_part == search_name: + imps.append((count, name_part)) + + for used_count, name_part in imps: + i = imports.ImportPath(stmt, kill_count=count - used_count, + direct_resolve=True) + f = i.follow(is_goto=True) + if set(f) & set(definitions): + names.append(api_classes.RelatedName(name_part, stmt)) + else: + calls = _scan_array(stmt.get_assignment_calls(), search_name) + for d in stmt.assignment_details: + if not is_definition(d[1]): + calls += _scan_array(d[1], search_name) + for call in calls: + names += check_call(call) + return names + + +def related_name_add_import_modules(definitions, search_name): + """ Adds the modules of the imports """ + new = set() + for d in definitions: + if isinstance(d.parent, parsing.Import): + s = imports.ImportPath(d.parent, direct_resolve=True) + try: + new.add(s.follow(is_goto=True)[0]) + except IndexError: + pass + return set(definitions) | new + + +def check_flow_information(flow, search_name, pos): + """ Try to find out the type of a variable just with the information that + is given by the flows: e.g. It is also responsible for assert checks. + >>> if isinstance(k, str): + >>> k. # <- completion here + + ensures that `k` is a string. + """ + result = [] + if isinstance(flow, parsing.Scope) and not result: + for ass in reversed(flow.asserts): + if pos is None or ass.start_pos > pos: + continue + result = check_statement_information(ass, search_name) + if result: + break + + if isinstance(flow, parsing.Flow) and not result: + if flow.command in ['if', 'while'] and len(flow.inits) == 1: + result = check_statement_information(flow.inits[0], search_name) + return result + + +def check_statement_information(stmt, search_name): + try: + ass = stmt.get_assignment_calls() + try: + call = ass.get_only_subelement() + except AttributeError: + assert False + assert type(call) == parsing.Call and str(call.name) == 'isinstance' + assert bool(call.execution) + + # isinstance check + isinst = call.execution.values + assert len(isinst) == 2 # has two params + assert len(isinst[0]) == 1 + assert len(isinst[1]) == 1 + assert isinstance(isinst[0][0], parsing.Call) + # names fit? + assert str(isinst[0][0].name) == search_name + classes_call = isinst[1][0] # class_or_type_or_tuple + assert isinstance(classes_call, parsing.Call) + result = [] + for c in evaluate.follow_call(classes_call): + if isinstance(c, evaluate.Array): + result += c.get_index_types() + else: + result.append(c) + for i, c in enumerate(result): + result[i] = evaluate.Instance(c) + return result + except AssertionError: + return [] diff --git a/common/.local/lib/python2.7/site-packages/jedi/evaluate.py b/common/.local/lib/python2.7/site-packages/jedi/evaluate.py new file mode 100644 index 0000000..5b3d212 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/evaluate.py @@ -0,0 +1,1614 @@ +""" +This is the core part of jedi. Most of the logic, how to evaluate certain +objects (imports, etc.) is here. + +The functions should be described in their docstrings. However, there are some +classes, which are used to store the values. After those classes, there are the +search functions `get_names_for_scope` and `get_scopes_for_name`. At the end +there are the `follow_` functions, which evaluate a statement, or parts of a +statement. + +TODO super() +TODO nonlocal statement, needed or can be ignored? (py3k) +""" +from _compatibility import next, property, hasattr, is_py3k, use_metaclass, \ + unicode + +import sys +import itertools +import copy + +import parsing +import debug +import builtin +import imports +import helpers +import dynamic +import docstrings + +memoize_caches = [] +faked_scopes = [] + + +class DecoratorNotFound(LookupError): + """ + Decorators are sometimes not found, if that happens, that error is raised. + """ + pass + + +class MultiLevelStopIteration(Exception): + """ + StopIteration's get catched pretty easy by for loops, let errors propagate. + """ + pass + + +class MultiLevelAttributeError(Exception): + """ + Important, because `__getattr__` and `hasattr` catch AttributeErrors + implicitly. This is really evil (mainly because of `__getattr__`). + `hasattr` in Python 2 is even more evil, because it catches ALL exceptions. + Therefore this class has to be a `BaseException` and not an `Exception`. + But because I rewrote hasattr, we can now switch back to `Exception`. + + :param base: return values of sys.exc_info(). + """ + def __init__(self, base): + self.base = base + + def __str__(self): + import traceback + tb = traceback.format_exception(*self.base) + return 'Original:\n\n' + ''.join(tb) + + +def clear_caches(): + """ + Clears all caches of this and related modules. Jedi caches many things, + that should be completed after each completion finishes. The only things + that stays is the module cache (which is not deleted here). + """ + global memoize_caches, faked_scopes + + for m in memoize_caches: + m.clear() + + dynamic.search_param_cache.clear() + helpers.ExecutionRecursionDecorator.reset() + + # memorize_caches must never be deleted, because the dicts will get lost in + # the wrappers. + faked_scopes = [] + + follow_statement.reset() + + imports.imports_processed = 0 + + +def memoize_default(default=None): + """ + This is a typical memoization decorator, BUT there is one difference: + To prevent recursion it sets defaults. + + Preventing recursion is in this case the much bigger use than speed. I + don't think, that there is a big speed difference, but there are many cases + where recursion could happen (think about a = b; b = a). + """ + def func(function): + memo = {} + memoize_caches.append(memo) + + def wrapper(*args, **kwargs): + key = (args, frozenset(kwargs.items())) + if key in memo: + return memo[key] + else: + memo[key] = default + rv = function(*args, **kwargs) + memo[key] = rv + return rv + return wrapper + return func + + +class CachedMetaClass(type): + """ + This is basically almost the same than the decorator above, it just caches + class initializations. I haven't found any other way, so I do it with meta + classes. + """ + @memoize_default() + def __call__(self, *args, **kwargs): + return super(CachedMetaClass, self).__call__(*args, **kwargs) + + +class Executable(parsing.Base): + """ An instance is also an executable - because __init__ is called """ + def __init__(self, base, var_args=None): + self.base = base + # The param input array. + if var_args is None: + var_args = parsing.Array(None, None) + self.var_args = var_args + + def get_parent_until(self, *args, **kwargs): + return self.base.get_parent_until(*args, **kwargs) + + @property + def parent(self): + return self.base.parent + + +class Instance(use_metaclass(CachedMetaClass, Executable)): + """ This class is used to evaluate instances. """ + def __init__(self, base, var_args=None): + super(Instance, self).__init__(base, var_args) + if str(base.name) in ['list', 'set'] \ + and builtin.Builtin.scope == base.get_parent_until(): + # compare the module path with the builtin name. + self.var_args = dynamic.check_array_instances(self) + else: + # need to execute the __init__ function, because the dynamic param + # searching needs it. + try: + self.execute_subscope_by_name('__init__', self.var_args) + except KeyError: + pass + # Generated instances are classes that are just generated by self + # (No var_args) used. + self.is_generated = False + + @memoize_default() + def get_init_execution(self, func): + func = InstanceElement(self, func, True) + return Execution(func, self.var_args) + + def get_func_self_name(self, func): + """ + Returns the name of the first param in a class method (which is + normally self + """ + try: + return func.params[0].used_vars[0].names[0] + except IndexError: + return None + + def get_self_properties(self): + def add_self_dot_name(name): + n = copy.copy(name) + n.names = n.names[1:] + names.append(InstanceElement(self, n)) + + names = [] + # This loop adds the names of the self object, copies them and removes + # the self. + for sub in self.base.subscopes: + if isinstance(sub, parsing.Class): + continue + # Get the self name, if there's one. + self_name = self.get_func_self_name(sub) + if self_name: + # Check the __init__ function. + if sub.name.get_code() == '__init__': + sub = self.get_init_execution(sub) + for n in sub.get_set_vars(): + # Only names with the selfname are being added. + # It is also important, that they have a len() of 2, + # because otherwise, they are just something else + if n.names[0] == self_name and len(n.names) == 2: + add_self_dot_name(n) + + for s in self.base.get_super_classes(): + if s == self.base: + # I don't know how this could happen... But saw it once. + continue + names += Instance(s).get_self_properties() + + return names + + def get_subscope_by_name(self, name): + sub = self.base.get_subscope_by_name(name) + return InstanceElement(self, sub, True) + + def execute_subscope_by_name(self, name, args=None): + if args is None: + args = helpers.generate_param_array([]) + method = self.get_subscope_by_name(name) + if args.parent_stmt is None: + args.parent_stmt = method + return Execution(method, args).get_return_types() + + def get_descriptor_return(self, obj): + """ Throws a KeyError if there's no method. """ + # Arguments in __get__ descriptors are obj, class. + # `method` is the new parent of the array, don't know if that's good. + v = [obj, obj.base] if isinstance(obj, Instance) else [None, obj] + args = helpers.generate_param_array(v) + return self.execute_subscope_by_name('__get__', args) + + @memoize_default([]) + def get_defined_names(self): + """ + Get the instance vars of a class. This includes the vars of all + classes + """ + names = self.get_self_properties() + + class_names = self.base.get_defined_names() + for var in class_names: + names.append(InstanceElement(self, var, True)) + return names + + def scope_generator(self): + """ + An Instance has two scopes: The scope with self names and the class + scope. Instance variables have priority over the class scope. + """ + yield self, self.get_self_properties() + + names = [] + class_names = self.base.get_defined_names() + for var in class_names: + names.append(InstanceElement(self, var, True)) + yield self, names + + def get_index_types(self, index=None): + args = helpers.generate_param_array([] if index is None else [index]) + try: + return self.execute_subscope_by_name('__getitem__', args) + except KeyError: + debug.warning('No __getitem__, cannot access the array.') + return [] + + def __getattr__(self, name): + if name not in ['start_pos', 'end_pos', 'name', 'get_imports', + 'docstr', 'asserts']: + raise AttributeError("Instance %s: Don't touch this (%s)!" + % (self, name)) + return getattr(self.base, name) + + def __repr__(self): + return "" % \ + (type(self).__name__, self.base, len(self.var_args or [])) + + +class InstanceElement(use_metaclass(CachedMetaClass)): + """ + InstanceElement is a wrapper for any object, that is used as an instance + variable (e.g. self.variable or class methods). + """ + def __init__(self, instance, var, is_class_var=False): + if isinstance(var, parsing.Function): + var = Function(var) + elif isinstance(var, parsing.Class): + var = Class(var) + self.instance = instance + self.var = var + self.is_class_var = is_class_var + + @property + @memoize_default() + def parent(self): + par = self.var.parent + if isinstance(par, Class) and par == self.instance.base \ + or isinstance(par, parsing.Class) \ + and par == self.instance.base.base: + par = self.instance + elif not isinstance(par, parsing.Module): + par = InstanceElement(self.instance, par, self.is_class_var) + return par + + def get_parent_until(self, *args, **kwargs): + return parsing.Simple.get_parent_until(self, *args, **kwargs) + + def get_decorated_func(self): + """ Needed because the InstanceElement should not be stripped """ + func = self.var.get_decorated_func() + if func == self.var: + return self + return func + + def get_assignment_calls(self): + # Copy and modify the array. + origin = self.var.get_assignment_calls() + # Delete parent, because it isn't used anymore. + new = helpers.fast_parent_copy(origin) + par = InstanceElement(self.instance, origin.parent_stmt, + self.is_class_var) + new.parent_stmt = par + faked_scopes.append(par) + faked_scopes.append(new) + return new + + def __getattr__(self, name): + return getattr(self.var, name) + + def isinstance(self, *cls): + return isinstance(self.var, cls) + + def __repr__(self): + return "<%s of %s>" % (type(self).__name__, self.var) + + +class Class(use_metaclass(CachedMetaClass, parsing.Base)): + """ + This class is not only important to extend `parsing.Class`, it is also a + important for descriptors (if the descriptor methods are evaluated or not). + """ + def __init__(self, base): + self.base = base + + @memoize_default(default=[]) + def get_super_classes(self): + supers = [] + # TODO care for mro stuff (multiple super classes). + for s in self.base.supers: + # Super classes are statements. + for cls in follow_statement(s): + if not isinstance(cls, Class): + debug.warning('Received non class, as a super class') + continue # Just ignore other stuff (user input error). + supers.append(cls) + if not supers and self.base.parent != builtin.Builtin.scope: + # add `object` to classes + supers += get_scopes_for_name(builtin.Builtin.scope, 'object') + return supers + + @memoize_default(default=[]) + def get_defined_names(self): + def in_iterable(name, iterable): + """ checks if the name is in the variable 'iterable'. """ + for i in iterable: + # Only the last name is important, because these names have a + # maximal length of 2, with the first one being `self`. + if i.names[-1] == name.names[-1]: + return True + return False + + result = self.base.get_defined_names() + super_result = [] + # TODO mro! + for cls in self.get_super_classes(): + # Get the inherited names. + for i in cls.get_defined_names(): + if not in_iterable(i, result): + super_result.append(i) + result += super_result + return result + + def get_subscope_by_name(self, name): + for sub in reversed(self.subscopes): + if sub.name.get_code() == name: + return sub + raise KeyError("Couldn't find subscope.") + + @property + def name(self): + return self.base.name + + def __getattr__(self, name): + if name not in ['start_pos', 'end_pos', 'parent', 'subscopes', + 'get_imports', 'get_parent_until', 'docstr', 'asserts']: + raise AttributeError("Don't touch this (%s)!" % name) + return getattr(self.base, name) + + def __repr__(self): + return "" % (type(self).__name__, self.base) + + +class Function(use_metaclass(CachedMetaClass, parsing.Base)): + """ + Needed because of decorators. Decorators are evaluated here. + """ + + def __init__(self, func, is_decorated=False): + """ This should not be called directly """ + self.base_func = func + self.is_decorated = is_decorated + + @property + @memoize_default() + def _decorated_func(self): + """ + Returns the function, that is to be executed in the end. + This is also the places where the decorators are processed. + """ + f = self.base_func + + # Only enter it, if has not already been processed. + if not self.is_decorated: + for dec in reversed(self.base_func.decorators): + debug.dbg('decorator:', dec, f) + dec_results = follow_statement(dec) + if not len(dec_results): + debug.warning('decorator func not found: %s in stmt %s' % + (self.base_func, dec)) + return None + if len(dec_results) > 1: + debug.warning('multiple decorators found', self.base_func, + dec_results) + decorator = dec_results.pop() + # Create param array. + old_func = Function(f, is_decorated=True) + params = helpers.generate_param_array([old_func], old_func) + faked_scopes.append(old_func) + + wrappers = Execution(decorator, params).get_return_types() + if not len(wrappers): + debug.warning('no wrappers found', self.base_func) + return None + if len(wrappers) > 1: + debug.warning('multiple wrappers found', self.base_func, + wrappers) + # This is here, that the wrapper gets executed. + f = wrappers[0] + + debug.dbg('decorator end', f) + if f != self.base_func and isinstance(f, parsing.Function): + f = Function(f) + return f + + def get_decorated_func(self): + if self._decorated_func is None: + raise DecoratorNotFound() + if self._decorated_func == self.base_func: + return self + return self._decorated_func + + def get_magic_method_names(self): + return builtin.Builtin.magic_function_scope.get_defined_names() + + def get_magic_method_scope(self): + return builtin.Builtin.magic_function_scope + + def __getattr__(self, name): + return getattr(self.base_func, name) + + def __repr__(self): + dec = '' + if self._decorated_func != self.base_func: + dec = " is " + repr(self._decorated_func) + return "" % (type(self).__name__, self.base_func, dec) + + +class Execution(Executable): + """ + This class is used to evaluate functions and their returns. + + This is the most complicated class, because it contains the logic to + transfer parameters. It is even more complicated, because there may be + multiple calls to functions and recursion has to be avoided. But this is + responsibility of the decorators. + """ + @memoize_default(default=[]) + @helpers.ExecutionRecursionDecorator + def get_return_types(self, evaluate_generator=False): + """ Get the return types of a function. """ + stmts = [] + if self.base.parent == builtin.Builtin.scope \ + and not isinstance(self.base, (Generator, Array)): + func_name = str(self.base.name) + + # some implementations of builtins: + if func_name == 'getattr': + # follow the first param + try: + objects = follow_call_list([self.var_args[0]]) + names = follow_call_list([self.var_args[1]]) + except IndexError: + debug.warning('getattr() called with to few args.') + return [] + + for obj in objects: + if not isinstance(obj, (Instance, Class)): + debug.warning('getattr called without instance') + continue + + for name in names: + key = name.var_args.get_only_subelement() + stmts += follow_path(iter([key]), obj, self.base) + return stmts + elif func_name == 'type': + # otherwise it would be a metaclass + if len(self.var_args) == 1: + objects = follow_call_list([self.var_args[0]]) + return [o.base for o in objects if isinstance(o, Instance)] + + if self.base.isinstance(Class): + # There maybe executions of executions. + stmts = [Instance(self.base, self.var_args)] + elif isinstance(self.base, Generator): + return self.base.iter_content() + else: + # Don't do this with exceptions, as usual, because some deeper + # exceptions could be catched - and I wouldn't know what happened. + try: + self.base.returns + except (AttributeError, DecoratorNotFound): + if hasattr(self.base, 'execute_subscope_by_name'): + try: + stmts = self.base.execute_subscope_by_name('__call__', + self.var_args) + except KeyError: + debug.warning("no __call__ func available", self.base) + else: + debug.warning("no execution possible", self.base) + else: + stmts = self._get_function_returns(evaluate_generator) + + debug.dbg('exec result: %s in %s' % (stmts, self)) + + return imports.strip_imports(stmts) + + def _get_function_returns(self, evaluate_generator): + """ A normal Function execution """ + # Feed the listeners, with the params. + for listener in self.base.listeners: + listener.execute(self.get_params()) + func = self.base.get_decorated_func() + if func.is_generator and not evaluate_generator: + return [Generator(func, self.var_args)] + else: + stmts = [] + for r in self.returns: + stmts += follow_statement(r) + return stmts + + @memoize_default(default=[]) + def get_params(self): + """ + This returns the params for an Execution/Instance and is injected as a + 'hack' into the parsing.Function class. + This needs to be here, because Instance can have __init__ functions, + which act the same way as normal functions. + """ + def gen_param_name_copy(param, keys=[], values=[], array_type=None): + """ + Create a param with the original scope (of varargs) as parent. + """ + parent_stmt = self.var_args.parent_stmt + pos = parent_stmt.start_pos if parent_stmt else None + calls = parsing.Array(pos, parsing.Array.NOARRAY, parent_stmt) + calls.values = values + calls.keys = keys + calls.type = array_type + new_param = copy.copy(param) + if parent_stmt is not None: + new_param.parent = parent_stmt + new_param._assignment_calls_calculated = True + new_param._assignment_calls = calls + new_param.is_generated = True + name = copy.copy(param.get_name()) + name.parent = new_param + faked_scopes.append(new_param) + return name + + result = [] + start_offset = 0 + if isinstance(self.base, InstanceElement): + # Care for self -> just exclude it and add the instance + start_offset = 1 + self_name = copy.copy(self.base.params[0].get_name()) + self_name.parent = self.base.instance + result.append(self_name) + + param_dict = {} + for param in self.base.params: + param_dict[str(param.get_name())] = param + # There may be calls, which don't fit all the params, this just ignores + # it. + var_arg_iterator = self.get_var_args_iterator() + + non_matching_keys = [] + keys_used = set() + keys_only = False + for param in self.base.params[start_offset:]: + # The value and key can both be null. There, the defaults apply. + # args / kwargs will just be empty arrays / dicts, respectively. + # Wrong value count is just ignored. If you try to test cases that + # are not allowed in Python, Jedi will maybe not show any + # completions. + key, value = next(var_arg_iterator, (None, None)) + while key: + keys_only = True + try: + key_param = param_dict[str(key)] + except KeyError: + non_matching_keys.append((key, value)) + else: + keys_used.add(str(key)) + result.append(gen_param_name_copy(key_param, + values=[value])) + key, value = next(var_arg_iterator, (None, None)) + + assignments = param.get_assignment_calls().values + assignment = assignments[0] + keys = [] + values = [] + array_type = None + if assignment[0] == '*': + # *args param + array_type = parsing.Array.TUPLE + if value: + values.append(value) + for key, value in var_arg_iterator: + # Iterate until a key argument is found. + if key: + var_arg_iterator.push_back((key, value)) + break + values.append(value) + elif assignment[0] == '**': + # **kwargs param + array_type = parsing.Array.DICT + if non_matching_keys: + keys, values = zip(*non_matching_keys) + else: + # normal param + if value: + values = [value] + else: + if param.assignment_details: + # No value: return the default values. + values = assignments + else: + # If there is no assignment detail, that means there is + # no assignment, just the result. Therefore nothing has + # to be returned. + values = [] + + # Just ignore all the params that are without a key, after one + # keyword argument was set. + if not keys_only or assignment[0] == '**': + keys_used.add(str(key)) + result.append(gen_param_name_copy(param, keys=keys, + values=values, array_type=array_type)) + + if keys_only: + # sometimes param arguments are not completely written (which would + # create an Exception, but we have to handle that). + for k in set(param_dict) - keys_used: + result.append(gen_param_name_copy(param_dict[k])) + return result + + def get_var_args_iterator(self): + """ + Yields a key/value pair, the key is None, if its not a named arg. + """ + def iterate(): + # `var_args` is typically an Array, and not a list. + for var_arg in self.var_args: + # empty var_arg + if len(var_arg) == 0: + yield None, None + # *args + elif var_arg[0] == '*': + arrays = follow_call_list([var_arg[1:]]) + for array in arrays: + if hasattr(array, 'get_contents'): + for field in array.get_contents(): + yield None, field + # **kwargs + elif var_arg[0] == '**': + arrays = follow_call_list([var_arg[1:]]) + for array in arrays: + if hasattr(array, 'get_contents'): + for key, field in array.get_contents(): + # Take the first index. + if isinstance(key, parsing.Name): + name = key + else: + # `parsing`.[Call|Function|Class] lookup. + name = key[0].name + yield name, field + # Normal arguments (including key arguments). + else: + if len(var_arg) > 1 and var_arg[1] == '=': + # This is a named parameter (var_arg[0] is a Call). + yield var_arg[0].name, var_arg[2:] + else: + yield None, var_arg + + return iter(parsing.PushBackIterator(iterate())) + + def get_set_vars(self): + return self.get_defined_names() + + def get_defined_names(self): + """ + Call the default method with the own instance (self implements all + the necessary functions). Add also the params. + """ + return self.get_params() + parsing.Scope.get_set_vars(self) + + def copy_properties(self, prop): + """ + Literally copies a property of a Function. Copying is very expensive, + because it is something like `copy.deepcopy`. However, these copied + objects can be used for the executions, as if they were in the + execution. + """ + # Copy all these lists into this local function. + attr = getattr(self.base, prop) + objects = [] + for element in attr: + copied = helpers.fast_parent_copy(element) + copied.parent = self._scope_copy(copied.parent) + if isinstance(copied, parsing.Function): + copied = Function(copied) + objects.append(copied) + faked_scopes.append(copied) + return objects + + def __getattr__(self, name): + if name not in ['start_pos', 'end_pos', 'imports']: + raise AttributeError('Tried to access %s: %s. Why?' % (name, self)) + return getattr(self.base, name) + + @memoize_default() + def _scope_copy(self, scope): + try: + """ Copies a scope (e.g. if) in an execution """ + # TODO method uses different scopes than the subscopes property. + + # just check the start_pos, sometimes it's difficult with closures + # to compare the scopes directly. + if scope.start_pos == self.start_pos: + return self + else: + copied = helpers.fast_parent_copy(scope) + copied.parent = self._scope_copy(copied.parent) + faked_scopes.append(copied) + return copied + except AttributeError: + raise MultiLevelAttributeError(sys.exc_info()) + + @property + @memoize_default() + def returns(self): + return self.copy_properties('returns') + + @property + @memoize_default() + def asserts(self): + return self.copy_properties('asserts') + + @property + @memoize_default() + def statements(self): + return self.copy_properties('statements') + + @property + @memoize_default() + def subscopes(self): + return self.copy_properties('subscopes') + + def get_statement_for_position(self, pos): + return parsing.Scope.get_statement_for_position(self, pos) + + def __repr__(self): + return "<%s of %s>" % \ + (type(self).__name__, self.base) + + +class Generator(use_metaclass(CachedMetaClass, parsing.Base)): + """ Cares for `yield` statements. """ + def __init__(self, func, var_args): + super(Generator, self).__init__() + self.func = func + self.var_args = var_args + + def get_defined_names(self): + """ + Returns a list of names that define a generator, which can return the + content of a generator. + """ + names = [] + none_pos = (0, 0) + executes_generator = ('__next__', 'send') + for n in ('close', 'throw') + executes_generator: + name = parsing.Name([(n, none_pos)], none_pos, none_pos) + if n in executes_generator: + name.parent = self + names.append(name) + debug.dbg('generator names', names) + return names + + def iter_content(self): + """ returns the content of __iter__ """ + return Execution(self.func, self.var_args).get_return_types(True) + + def get_index_types(self, index=None): + debug.warning('Tried to get array access on a generator', self) + return [] + + @property + def parent(self): + return self.func.parent + + def __repr__(self): + return "<%s of %s>" % (type(self).__name__, self.func) + + +class Array(use_metaclass(CachedMetaClass, parsing.Base)): + """ + Used as a mirror to parsing.Array, if needed. It defines some getter + methods which are important in this module. + """ + def __init__(self, array): + self._array = array + + def get_index_types(self, index_call_list=None): + """ Get the types of a specific index or all, if not given """ + # array slicing + if index_call_list is not None: + if index_call_list and [x for x in index_call_list if ':' in x]: + return [self] + + index_possibilities = list(follow_call_list(index_call_list)) + if len(index_possibilities) == 1: + # This is indexing only one element, with a fixed index number, + # otherwise it just ignores the index (e.g. [1+1]). + try: + # Multiple elements in the array are not wanted. var_args + # and get_only_subelement can raise AttributeErrors. + i = index_possibilities[0].var_args.get_only_subelement() + except AttributeError: + pass + else: + try: + return self.get_exact_index_types(i) + except (IndexError, KeyError): + pass + + result = list(self.follow_values(self._array.values)) + result += dynamic.check_array_additions(self) + return set(result) + + def get_exact_index_types(self, index): + """ Here the index is an int. Raises IndexError/KeyError """ + if self._array.type == parsing.Array.DICT: + old_index = index + index = None + for i, key_elements in enumerate(self._array.keys): + # Because we only want the key to be a string. + if len(key_elements) == 1: + try: + str_key = key_elements.get_code() + except AttributeError: + try: + str_key = key_elements[0].name + except AttributeError: + str_key = None + if old_index == str_key: + index = i + break + if index is None: + raise KeyError('No key found in dictionary') + values = [self._array[index]] + return self.follow_values(values) + + def follow_values(self, values): + """ helper function for the index getters """ + return follow_call_list(values) + + def get_defined_names(self): + """ + This method generates all ArrayElements for one parsing.Array. + It returns e.g. for a list: append, pop, ... + """ + # `array.type` is a string with the type, e.g. 'list'. + scope = get_scopes_for_name(builtin.Builtin.scope, self._array.type)[0] + scope = Instance(scope) + names = scope.get_defined_names() + return [ArrayElement(n) for n in names] + + def get_contents(self): + return self._array + + @property + def parent(self): + """ + Return the builtin scope as parent, because the arrays are builtins + """ + return builtin.Builtin.scope + + def get_parent_until(self, *args, **kwargs): + return builtin.Builtin.scope + + def __getattr__(self, name): + if name not in ['type', 'start_pos']: + raise AttributeError('Strange access: %s.' % name) + return getattr(self._array, name) + + def __repr__(self): + return "" % (type(self).__name__, self._array) + + +class ArrayElement(object): + """ + A name, e.g. `list.append`, it is used to access to original array methods. + """ + def __init__(self, name): + super(ArrayElement, self).__init__() + self.name = name + + def __getattr__(self, name): + # Set access privileges: + if name not in ['parent', 'names', 'start_pos', 'end_pos', 'get_code']: + raise AttributeError('Strange access: %s.' % name) + return getattr(self.name, name) + + def get_parent_until(self): + return builtin.Builtin.scope + + def __repr__(self): + return "<%s of %s>" % (type(self).__name__, self.name) + + +def get_defined_names_for_position(scope, position=None, start_scope=None): + """ + Deletes all names that are ahead of the position, except for some special + objects like instances, where the position doesn't matter. + + :param position: the position as a line/column tuple, default is infinity. + """ + names = scope.get_defined_names() + # Instances have special rules, always return all the possible completions, + # because class variables are always valid and the `self.` variables, too. + if (not position or isinstance(scope, (Array, Instance)) + or start_scope != scope + and isinstance(start_scope, (parsing.Function, Execution))): + return names + names_new = [] + for n in names: + if n.start_pos[0] is not None and n.start_pos < position: + names_new.append(n) + return names_new + + +def get_names_for_scope(scope, position=None, star_search=True, + include_builtin=True): + """ + Get all completions possible for the current scope. + The star search option is only here to provide an optimization. Otherwise + the whole thing would probably start a little recursive madness. + """ + in_func_scope = scope + non_flow = scope.get_parent_until(parsing.Flow, reverse=True, + include_current=True) + while scope: + # `parsing.Class` is used, because the parent is never `Class`. + # Ignore the Flows, because the classes and functions care for that. + # InstanceElement of Class is ignored, if it is not the start scope. + if not (scope != non_flow and scope.isinstance(parsing.Class) + or scope.isinstance(parsing.Flow) + or scope.isinstance(Instance) + and non_flow.isinstance(Function) + ): + try: + if isinstance(scope, Instance): + for g in scope.scope_generator(): + yield g + else: + yield scope, get_defined_names_for_position(scope, + position, in_func_scope) + except StopIteration: + raise MultiLevelStopIteration('StopIteration raised somewhere') + if scope.isinstance(parsing.ForFlow) and scope.is_list_comp: + # is a list comprehension + yield scope, scope.get_set_vars(is_internal_call=True) + + scope = scope.parent + # This is used, because subscopes (Flow scopes) would distort the + # results. + if scope and scope.isinstance(Function, parsing.Function, Execution): + in_func_scope = scope + + # Add star imports. + if star_search: + for s in imports.remove_star_imports(non_flow.get_parent_until()): + for g in get_names_for_scope(s, star_search=False): + yield g + + # Add builtins to the global scope. + if include_builtin: + builtin_scope = builtin.Builtin.scope + yield builtin_scope, builtin_scope.get_defined_names() + + +def get_scopes_for_name(scope, name_str, position=None, search_global=False, + is_goto=False): + """ + This is the search function. The most important part to debug. + `remove_statements` and `filter_statements` really are the core part of + this completion. + + :param position: Position of the last statement -> tuple of line, column + :return: List of Names. Their parents are the scopes, they are defined in. + :rtype: list + """ + def remove_statements(result): + """ + This is the part where statements are being stripped. + + Due to lazy evaluation, statements like a = func; b = a; b() have to be + evaluated. + """ + res_new = [] + for r in result: + add = [] + if r.isinstance(parsing.Statement): + check_instance = None + if isinstance(r, InstanceElement) and r.is_class_var: + check_instance = r.instance + r = r.var + + # Global variables handling. + if r.is_global(): + for token_name in r.token_list[1:]: + if isinstance(token_name, parsing.Name): + add = get_scopes_for_name(r.parent, + str(token_name)) + else: + # generated objects are used within executions, but these + # objects are in functions, and we have to dynamically + # execute first. + if isinstance(r, parsing.Param): + func = r.parent + # Instances are typically faked, if the instance is not + # called from outside. Here we check it for __init__ + # functions and return. + if isinstance(func, InstanceElement) \ + and func.instance.is_generated \ + and hasattr(func, 'name') \ + and str(func.name) == '__init__' \ + and r.position_nr > 0: # 0 would be self + r = func.var.params[r.position_nr] + + # add docstring knowledge + doc_params = docstrings.follow_param(r) + if doc_params: + res_new += doc_params + continue + + if not r.is_generated: + res_new += dynamic.search_params(r) + if not r.assignment_details: + # this means that there are no default params, + # so just ignore it. + continue + + scopes = follow_statement(r, seek_name=name_str) + add += remove_statements(scopes) + + if check_instance is not None: + # class renames + add = [InstanceElement(check_instance, a, True) + if isinstance(a, (Function, parsing.Function)) + else a for a in add] + res_new += add + else: + if isinstance(r, parsing.Class): + r = Class(r) + elif isinstance(r, parsing.Function): + r = Function(r) + if r.isinstance(Function): + try: + r = r.get_decorated_func() + except DecoratorNotFound: + continue + res_new.append(r) + debug.dbg('sfn remove, new: %s, old: %s' % (res_new, result)) + return res_new + + def filter_name(scope_generator): + """ + Filters all variables of a scope (which are defined in the + `scope_generator`), until the name fits. + """ + def handle_for_loops(loop): + # Take the first statement (for has always only + # one, remember `in`). And follow it. + if not len(loop.inits): + return [] + result = get_iterator_types(follow_statement(loop.inits[0])) + if len(loop.set_vars) > 1: + var_arr = loop.set_stmt.get_assignment_calls() + result = assign_tuples(var_arr, result, name_str) + return result + + def process(name): + """ + Returns the parent of a name, which means the element which stands + behind a name. + """ + result = [] + no_break_scope = False + par = name.parent + + if par.isinstance(parsing.Flow): + if par.command == 'for': + result += handle_for_loops(par) + else: + debug.warning('Flow: Why are you here? %s' % par.command) + elif par.isinstance(parsing.Param) \ + and par.parent is not None \ + and par.parent.parent.isinstance(parsing.Class) \ + and par.position_nr == 0: + # This is where self gets added - this happens at another + # place, if the var_args are clear. But sometimes the class is + # not known. Therefore add a new instance for self. Otherwise + # take the existing. + if isinstance(scope, InstanceElement): + inst = scope.instance + else: + inst = Instance(Class(par.parent.parent)) + inst.is_generated = True + result.append(inst) + elif par.isinstance(parsing.Statement): + def is_execution(arr): + for a in arr: + a = a[0] # rest is always empty with assignees + if a.isinstance(parsing.Array): + if is_execution(a): + return True + elif a.isinstance(parsing.Call): + if a.name == name and a.execution: + return True + return False + + is_exe = False + for op, assignee in par.assignment_details: + is_exe |= is_execution(assignee) + if is_exe: + # filter array[3] = ... + # TODO check executions for dict contents + pass + else: + details = par.assignment_details + if details and details[0][0] != '=': + no_break_scope = True + + # TODO this makes self variables non-breakable. wanted? + if isinstance(name, InstanceElement) \ + and not name.is_class_var: + no_break_scope = True + + result.append(par) + else: + result.append(par) + return result, no_break_scope + + flow_scope = scope + result = [] + # compare func uses the tuple of line/indent = line/column + comparison_func = lambda name: (name.start_pos) + + for nscope, name_list in scope_generator: + break_scopes = [] + # here is the position stuff happening (sorting of variables) + for name in sorted(name_list, key=comparison_func, reverse=True): + p = name.parent.parent if name.parent else None + if isinstance(p, InstanceElement) \ + and isinstance(p.var, parsing.Class): + p = p.var + if name_str == name.get_code() and p not in break_scopes: + r, no_break_scope = process(name) + if is_goto: + if r: + # Directly assign the name, but there has to be a + # result. + result.append(name) + else: + result += r + # for comparison we need the raw class + s = nscope.base if isinstance(nscope, Class) else nscope + # this means that a definition was found and is not e.g. + # in if/else. + if result and not no_break_scope: + if not name.parent or p == s: + break + break_scopes.append(p) + + while flow_scope: + # TODO check if result is in scope -> no evaluation necessary + n = dynamic.check_flow_information(flow_scope, name_str, + position) + if n: + result = n + break + + if result: + break + if flow_scope == nscope: + break + flow_scope = flow_scope.parent + flow_scope = nscope + if result: + break + + if not result and isinstance(nscope, Instance): + # getattr() / __getattr__ / __getattribute__ + result += check_getattr(nscope, name_str) + debug.dbg('sfn filter "%s" in %s: %s' % (name_str, nscope, result)) + return result + + def descriptor_check(result): + """ Processes descriptors """ + res_new = [] + for r in result: + if isinstance(scope, (Instance, Class)) \ + and hasattr(r, 'get_descriptor_return'): + # handle descriptors + try: + res_new += r.get_descriptor_return(scope) + continue + except KeyError: + pass + res_new.append(r) + return res_new + + if search_global: + scope_generator = get_names_for_scope(scope, position=position) + else: + if isinstance(scope, Instance): + scope_generator = scope.scope_generator() + else: + if isinstance(scope, (Class, parsing.Module)): + # classes are only available directly via chaining? + # strange stuff... + names = scope.get_defined_names() + else: + names = get_defined_names_for_position(scope, position) + scope_generator = iter([(scope, names)]) + + if is_goto: + return filter_name(scope_generator) + return descriptor_check(remove_statements(filter_name(scope_generator))) + + +def check_getattr(inst, name_str): + result = [] + # str is important to lose the NamePart! + name = parsing.Call(str(name_str), parsing.Call.STRING, (0, 0), inst) + args = helpers.generate_param_array([name]) + try: + result = inst.execute_subscope_by_name('__getattr__', args) + except KeyError: + pass + if not result: + # this is a little bit special. `__getattribute__` is executed + # before anything else. But: I know no use case, where this + # could be practical and the jedi would return wrong types. If + # you ever have something, let me know! + try: + result = inst.execute_subscope_by_name('__getattribute__', args) + except KeyError: + pass + return result + + +def get_iterator_types(inputs): + """ Returns the types of any iterator (arrays, yields, __iter__, etc). """ + iterators = [] + # Take the first statement (for has always only + # one, remember `in`). And follow it. + for it in inputs: + if isinstance(it, (Generator, Array, dynamic.ArrayInstance)): + iterators.append(it) + else: + if not hasattr(it, 'execute_subscope_by_name'): + debug.warning('iterator/for loop input wrong', it) + continue + try: + iterators += it.execute_subscope_by_name('__iter__') + except KeyError: + debug.warning('iterators: No __iter__ method found.') + + result = [] + for gen in iterators: + if isinstance(gen, Array): + # Array is a little bit special, since this is an internal + # array, but there's also the list builtin, which is + # another thing. + result += gen.get_index_types() + elif isinstance(gen, Instance): + # __iter__ returned an instance. + name = '__next__' if is_py3k else 'next' + try: + result += gen.execute_subscope_by_name(name) + except KeyError: + debug.warning('Instance has no __next__ function', gen) + else: + # is a generator + result += gen.iter_content() + return result + + +def assign_tuples(tup, results, seek_name): + """ + This is a normal assignment checker. In python functions and other things + can return tuples: + >>> a, b = 1, "" + >>> a, (b, c) = 1, ("", 1.0) + + Here, if seek_name is "a", the number type will be returned. + The first part (before `=`) is the param tuples, the second one result. + + :type tup: parsing.Array + """ + def eval_results(index): + types = [] + for r in results: + if hasattr(r, "get_exact_index_types"): + try: + types += r.get_exact_index_types(index) + except IndexError: + pass + else: + debug.warning("invalid tuple lookup %s of result %s in %s" + % (tup, results, seek_name)) + + return types + + result = [] + if tup.type == parsing.Array.NOARRAY: + # Here we have unnessecary braces, which we just remove. + arr = tup.get_only_subelement() + if type(arr) == parsing.Call: + if arr.name.names[-1] == seek_name: + result = results + else: + result = assign_tuples(arr, results, seek_name) + else: + for i, t in enumerate(tup): + # Used in assignments. There is just one call and no other things, + # therefore we can just assume, that the first part is important. + if len(t) != 1: + raise AttributeError('Array length should be 1') + t = t[0] + + # Check the left part, if there are still tuples in it or a Call. + if isinstance(t, parsing.Array): + # These are "sub"-tuples. + result += assign_tuples(t, eval_results(i), seek_name) + else: + if t.name.names[-1] == seek_name: + result += eval_results(i) + return result + + +@helpers.RecursionDecorator +@memoize_default(default=[]) +def follow_statement(stmt, seek_name=None): + """ + The starting point of the completion. A statement always owns a call list, + which are the calls, that a statement does. + In case multiple names are defined in the statement, `seek_name` returns + the result for this name. + + :param stmt: A `parsing.Statement`. + :param seek_name: A string. + """ + debug.dbg('follow_stmt %s (%s)' % (stmt, seek_name)) + call_list = stmt.get_assignment_calls() + debug.dbg('calls: %s' % call_list) + + try: + result = follow_call_list(call_list) + except AttributeError: + # This is so evil! But necessary to propagate errors. The attribute + # errors here must not be catched, because they shouldn't exist. + raise MultiLevelAttributeError(sys.exc_info()) + + # Assignment checking is only important if the statement defines multiple + # variables. + if len(stmt.get_set_vars()) > 1 and seek_name and stmt.assignment_details: + new_result = [] + for op, set_vars in stmt.assignment_details: + new_result += assign_tuples(set_vars, result, seek_name) + result = new_result + return set(result) + + +def follow_call_list(call_list): + """ + The call_list has a special structure. + This can be either `parsing.Array` or `list of list`. + It is used to evaluate a two dimensional object, that has calls, arrays and + operators in it. + """ + def evaluate_list_comprehension(lc, parent=None): + input = lc.input + nested_lc = lc.input.token_list[0] + if isinstance(nested_lc, parsing.ListComprehension): + # is nested LC + input = nested_lc.stmt + loop = parsing.ForFlow([input], lc.stmt.start_pos, + lc.middle, True) + if parent is None: + loop.parent = lc.stmt.parent + else: + loop.parent = parent + + if isinstance(nested_lc, parsing.ListComprehension): + loop = evaluate_list_comprehension(nested_lc, loop) + return loop + + if parsing.Array.is_type(call_list, parsing.Array.TUPLE, + parsing.Array.DICT): + # Tuples can stand just alone without any braces. These would be + # recognized as separate calls, but actually are a tuple. + result = follow_call(call_list) + else: + result = [] + for calls in call_list: + calls_iterator = iter(calls) + for call in calls_iterator: + if parsing.Array.is_type(call, parsing.Array.NOARRAY): + result += follow_call_list(call) + elif isinstance(call, parsing.ListComprehension): + loop = evaluate_list_comprehension(call) + stmt = copy.copy(call.stmt) + stmt.parent = loop + # create a for loop which does the same as list + # comprehensions + result += follow_statement(stmt) + else: + # With things like params, these can also be functions... + if isinstance(call, (Function, Class, Instance, + dynamic.ArrayInstance)): + result.append(call) + # The string tokens are just operations (+, -, etc.) + elif not isinstance(call, (str, unicode)): + if str(call.name) == 'if': + # Ternary operators. + while True: + try: + call = next(calls_iterator) + except StopIteration: + break + try: + if str(call.name) == 'else': + break + except AttributeError: + pass + continue + result += follow_call(call) + elif call == '*': + if [r for r in result if isinstance(r, Array) + or isinstance(r, Instance) + and str(r.name) == 'str']: + # if it is an iterable, ignore * operations + next(calls_iterator) + return set(result) + + +def follow_call(call): + """ Follow a call is following a function, variable, string, etc. """ + scope = call.parent_stmt.parent + path = call.generate_call_path() + position = call.parent_stmt.start_pos + return follow_call_path(path, scope, position) + + +def follow_call_path(path, scope, position): + """ Follows a path generated by `parsing.Call.generate_call_path()` """ + current = next(path) + + if isinstance(current, parsing.Array): + result = [Array(current)] + else: + if not isinstance(current, parsing.NamePart): + if current.type in (parsing.Call.STRING, parsing.Call.NUMBER): + t = type(current.name).__name__ + scopes = get_scopes_for_name(builtin.Builtin.scope, t) + else: + debug.warning('unknown type:', current.type, current) + scopes = [] + # Make instances of those number/string objects. + arr = helpers.generate_param_array([current.name]) + scopes = [Instance(s, arr) for s in scopes] + else: + # This is the first global lookup. + scopes = get_scopes_for_name(scope, current, position=position, + search_global=True) + result = imports.strip_imports(scopes) + + return follow_paths(path, result, scope, position=position) + + +def follow_paths(path, results, call_scope, position=None): + """ + In each result, `path` must be followed. Copies the path iterator. + """ + results_new = [] + if results: + if len(results) > 1: + iter_paths = itertools.tee(path, len(results)) + else: + iter_paths = [path] + + for i, r in enumerate(results): + fp = follow_path(iter_paths[i], r, call_scope, position=position) + if fp is not None: + results_new += fp + else: + # This means stop iteration. + return results + return results_new + + +def follow_path(path, scope, call_scope, position=None): + """ + Uses a generator and tries to complete the path, e.g. + >>> foo.bar.baz + + `follow_path` is only responsible for completing `.bar.baz`, the rest is + done in the `follow_call` function. + """ + # Current is either an Array or a Scope. + try: + current = next(path) + except StopIteration: + return None + debug.dbg('follow %s in scope %s' % (current, scope)) + + result = [] + if isinstance(current, parsing.Array): + # This must be an execution, either () or []. + if current.type == parsing.Array.LIST: + if hasattr(scope, 'get_index_types'): + result = scope.get_index_types(current) + elif current.type not in [parsing.Array.DICT]: + # Scope must be a class or func - make an instance or execution. + debug.dbg('exe', scope) + result = Execution(scope, current).get_return_types() + else: + # Curly braces are not allowed, because they make no sense. + debug.warning('strange function call with {}', current, scope) + else: + # The function must not be decorated with something else. + if scope.isinstance(Function): + scope = scope.get_magic_method_scope() + else: + # This is the typical lookup while chaining things. + if filter_private_variable(scope, call_scope, current): + return [] + result = imports.strip_imports(get_scopes_for_name(scope, current, + position=position)) + return follow_paths(path, set(result), call_scope, position=position) + + +def filter_private_variable(scope, call_scope, var_name): + if isinstance(var_name, (str, unicode)) \ + and var_name.startswith('__') and isinstance(scope, Instance): + s = call_scope.get_parent_until((parsing.Class, Instance), + include_current=True) + if s != scope and s != scope.base.base: + return True + return False + + +def goto(stmt, call_path=None): + if call_path is None: + arr = stmt.get_assignment_calls() + call = arr.get_only_subelement() + call_path = list(call.generate_call_path()) + + scope = stmt.parent + pos = stmt.start_pos + call_path, search = call_path[:-1], call_path[-1] + if call_path: + scopes = follow_call_path(iter(call_path), scope, pos) + search_global = False + pos = None + else: + scopes = [scope] + search_global = True + follow_res = [] + for s in scopes: + follow_res += get_scopes_for_name(s, search, pos, + search_global=search_global, is_goto=True) + return follow_res, search diff --git a/common/.local/lib/python2.7/site-packages/jedi/helpers.py b/common/.local/lib/python2.7/site-packages/jedi/helpers.py new file mode 100644 index 0000000..b1f6e4c --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/helpers.py @@ -0,0 +1,266 @@ +import copy +import contextlib + +import parsing +import evaluate +import debug +import builtin +import settings + + +class RecursionDecorator(object): + """ + A decorator to detect recursions in statements. In a recursion a statement + at the same place, in the same module may not be executed two times. + """ + def __init__(self, func): + self.func = func + self.reset() + + def __call__(self, stmt, *args, **kwargs): + #print stmt, len(self.node_statements()) + if self.push_stmt(stmt): + return [] + else: + result = self.func(stmt, *args, **kwargs) + self.pop_stmt() + return result + + def push_stmt(self, stmt): + self.current = RecursionNode(stmt, self.current) + if self._check_recursion(): + debug.warning('catched recursion', stmt) + self.pop_stmt() + return True + return False + + def pop_stmt(self): + if self.current is not None: + # I don't know how current can be None, but sometimes it happens + # with Python3. + self.current = self.current.parent + + def _check_recursion(self): + test = self.current + while True: + test = test.parent + if self.current == test: + return True + if not test: + return False + + def reset(self): + self.top = None + self.current = None + + def node_statements(self): + result = [] + n = self.current + while n: + result.insert(0, n.stmt) + n = n.parent + return result + + +class RecursionNode(object): + """ A node of the RecursionDecorator. """ + def __init__(self, stmt, parent): + self.script = stmt.get_parent_until() + self.position = stmt.start_pos + self.parent = parent + self.stmt = stmt + + # Don't check param instances, they are not causing recursions + # The same's true for the builtins, because the builtins are really + # simple. + self.is_ignored = isinstance(stmt, parsing.Param) \ + or (self.script == builtin.Builtin.scope) + + def __eq__(self, other): + if not other: + return None + return self.script == other.script \ + and self.position == other.position \ + and not self.is_ignored and not other.is_ignored + + +class ExecutionRecursionDecorator(object): + """ + Catches recursions of executions. + It is designed like a Singelton. Only one instance should exist. + """ + def __init__(self, func): + self.func = func + self.reset() + + def __call__(self, execution, evaluate_generator=False): + debug.dbg('Execution recursions: %s' % execution, self.recursion_level, + self.execution_count, len(self.execution_funcs)) + if self.check_recursion(execution, evaluate_generator): + result = [] + else: + result = self.func(execution, evaluate_generator) + self.cleanup() + return result + + @classmethod + def cleanup(cls): + cls.parent_execution_funcs.pop() + cls.recursion_level -= 1 + + @classmethod + def check_recursion(cls, execution, evaluate_generator): + in_par_execution_funcs = execution.base in cls.parent_execution_funcs + in_execution_funcs = execution.base in cls.execution_funcs + cls.recursion_level += 1 + cls.execution_count += 1 + cls.execution_funcs.add(execution.base) + cls.parent_execution_funcs.append(execution.base) + + if cls.execution_count > settings.max_executions: + return True + + if isinstance(execution.base, (evaluate.Generator, evaluate.Array)): + return False + module = execution.get_parent_until() + if evaluate_generator or module == builtin.Builtin.scope: + return False + + if in_par_execution_funcs: + if cls.recursion_level > settings.max_function_recursion_level: + return True + if in_execution_funcs and \ + len(cls.execution_funcs) > settings.max_until_execution_unique: + return True + if cls.execution_count > settings.max_executions_without_builtins: + return True + return False + + @classmethod + def reset(cls): + cls.recursion_level = 0 + cls.parent_execution_funcs = [] + cls.execution_funcs = set() + cls.execution_count = 0 + + +def fast_parent_copy(obj): + """ + Much, much faster than copy.deepcopy, but just for certain elements. + """ + new_elements = {} + + def recursion(obj): + new_obj = copy.copy(obj) + new_elements[obj] = new_obj + + items = new_obj.__dict__.items() + for key, value in items: + # replace parent (first try _parent and then parent) + if key in ['parent', '_parent', '_parent_stmt'] \ + and value is not None: + if key == 'parent' and '_parent' in items: + # parent can be a property + continue + try: + setattr(new_obj, key, new_elements[value]) + except KeyError: + pass + elif key in ['parent_stmt', 'parent_function']: + continue + elif isinstance(value, list): + setattr(new_obj, key, list_rec(value)) + elif isinstance(value, (parsing.Simple, parsing.Call)): + setattr(new_obj, key, recursion(value)) + return new_obj + + def list_rec(list_obj): + copied_list = list_obj[:] # lists, tuples, strings, unicode + for i, el in enumerate(copied_list): + if isinstance(el, (parsing.Simple, parsing.Call)): + copied_list[i] = recursion(el) + elif isinstance(el, list): + copied_list[i] = list_rec(el) + return copied_list + return recursion(obj) + + +def generate_param_array(args_tuple, parent_stmt=None): + """ This generates an array, that can be used as a param. """ + values = [] + for arg in args_tuple: + if arg is None: + values.append([]) + else: + values.append([arg]) + pos = None + arr = parsing.Array(pos, parsing.Array.TUPLE, parent_stmt, values=values) + evaluate.faked_scopes.append(arr) + return arr + + +def scan_array_for_pos(arr, pos): + """ + Returns the function Call that match search_name in an Array. + Makes changes to arr! + """ + def check_arr_index(): + positions = arr.arr_el_pos + for index, comma_pos in enumerate(positions): + if pos < comma_pos: + return index + return len(positions) + + call = None + stop = False + for sub in arr.values: + call = None + for s in sub: + if isinstance(s, parsing.Array): + new = scan_array_for_pos(s, pos) + if new[0] is not None: + call, index, stop = new + if stop: + return call, index, stop + elif isinstance(s, parsing.Call): + start_s = s + # check parts of calls + while s is not None: + if s.start_pos >= pos: + return call, check_arr_index(), stop + elif s.execution is not None: + end = s.execution.end_pos + if s.execution.start_pos < pos and \ + (end is None or pos < end): + c, index, stop = scan_array_for_pos( + s.execution, pos) + if stop: + return c, index, stop + + # call should return without execution and + # next + reset = c or s + if reset.execution.type not in \ + [parsing.Array.TUPLE, + parsing.Array.NOARRAY]: + return start_s, index, False + + reset.execution = None + reset.next = None + return c or start_s, index, True + s = s.next + + # The third return is just necessary for recursion inside, because + # it needs to know when to stop iterating. + return call, check_arr_index(), stop + + +@contextlib.contextmanager +def scale_speed_settings(factor): + a = settings.max_executions + b = settings.max_until_execution_unique + settings.max_executions *= factor + settings.max_until_execution_unique *= factor + yield + settings.max_executions = a + settings.max_until_execution_unique = b diff --git a/common/.local/lib/python2.7/site-packages/jedi/imports.py b/common/.local/lib/python2.7/site-packages/jedi/imports.py new file mode 100644 index 0000000..03a76ca --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/imports.py @@ -0,0 +1,332 @@ +from __future__ import with_statement + +import os +import pkgutil +import imp +import sys +import time + +import builtin +import modules +import debug +import parsing +import evaluate +import itertools +import settings + +# for debugging purposes only +imports_processed = 0 + +star_import_cache = {} + + +class ModuleNotFound(Exception): + pass + + +class ImportPath(parsing.Base): + """ + An ImportPath is the path of a `parsing.Import` object. + """ + class _GlobalNamespace(object): + def get_defined_names(self): + return [] + + def get_imports(self): + return [] + + @property + def start_pos(self): + return (0, 0) + + def get_parent_until(self): + return None + + GlobalNamespace = _GlobalNamespace() + + def __init__(self, import_stmt, is_like_search=False, kill_count=0, + direct_resolve=False): + self.import_stmt = import_stmt + self.is_like_search = is_like_search + self.direct_resolve = direct_resolve + self.is_partial_import = bool(kill_count) + path = import_stmt.get_parent_until().path + self.file_path = os.path.dirname(path) if path is not None else None + + # rest is import_path resolution + self.import_path = [] + if import_stmt.from_ns: + self.import_path += import_stmt.from_ns.names + if import_stmt.namespace: + if self.is_nested_import() and not direct_resolve: + self.import_path.append(import_stmt.namespace.names[0]) + else: + self.import_path += import_stmt.namespace.names + + for i in range(kill_count + int(is_like_search)): + self.import_path.pop() + + def __repr__(self): + return '<%s: %s>' % (type(self).__name__, self.import_stmt) + + def is_nested_import(self): + """ + This checks for the special case of nested imports, without aliases and + from statement: + >>> import foo.bar + """ + return not self.import_stmt.alias and not self.import_stmt.from_ns \ + and len(self.import_stmt.namespace.names) > 1 \ + and not self.direct_resolve + + def get_nested_import(self, parent): + """ + See documentation of `self.is_nested_import`. + Generates an Import statement, that can be used to fake nested imports. + """ + i = self.import_stmt + # This is not an existing Import statement. Therefore, set position to + # 0 (0 is not a valid line number). + zero = (0, 0) + n = parsing.Name(i.namespace.names[1:], zero, zero, self.import_stmt) + new = parsing.Import(zero, zero, n) + new.parent = parent + evaluate.faked_scopes.append(new) + debug.dbg('Generated a nested import: %s' % new) + return new + + def get_defined_names(self, on_import_stmt=False): + names = [] + for scope in self.follow(): + if scope is ImportPath.GlobalNamespace: + if self.import_stmt.relative_count == 0: + names += self.get_module_names() + + if self.file_path is not None: + path = os.path.abspath(self.file_path) + for i in range(self.import_stmt.relative_count - 1): + path = os.path.dirname(path) + names += self.get_module_names([path]) + else: + if on_import_stmt and isinstance(scope, parsing.Module) \ + and scope.path.endswith('__init__.py'): + pkg_path = os.path.dirname(scope.path) + names += self.get_module_names([pkg_path]) + for s, scope_names in evaluate.get_names_for_scope(scope, + include_builtin=False): + for n in scope_names: + if self.import_stmt.from_ns is None \ + or self.is_partial_import: + # from_ns must be defined to access module + # values plus a partial import means that there + # is something after the import, which + # automatically implies that there must not be + # any non-module scope. + continue + names.append(n) + return names + + def get_module_names(self, search_path=None): + """ + Get the names of all modules in the search_path. This means file names + and not names defined in the files. + """ + if not search_path: + search_path = self.sys_path_with_modifications() + names = [] + for module_loader, name, is_pkg in pkgutil.iter_modules(search_path): + inf_pos = (float('inf'), float('inf')) + names.append(parsing.Name([(name, inf_pos)], inf_pos, inf_pos, + self.import_stmt)) + return names + + def sys_path_with_modifications(self): + module = self.import_stmt.get_parent_until() + return modules.sys_path_with_modifications(module) + + def follow(self, is_goto=False): + """ + Returns the imported modules. + """ + if evaluate.follow_statement.push_stmt(self.import_stmt): + # check recursion + return [] + + if self.import_path: + try: + scope, rest = self._follow_file_system() + except ModuleNotFound: + debug.warning('Module not found: ' + str(self.import_stmt)) + evaluate.follow_statement.pop_stmt() + return [] + + scopes = [scope] + scopes += itertools.chain.from_iterable( + remove_star_imports(s) for s in scopes) + + # follow the rest of the import (not FS -> classes, functions) + if len(rest) > 1 or rest and self.is_like_search: + scopes = [] + elif rest: + if is_goto: + scopes = itertools.chain.from_iterable( + evaluate.get_scopes_for_name(s, rest[0], is_goto=True) + for s in scopes) + else: + scopes = itertools.chain.from_iterable( + evaluate.follow_path(iter(rest), s, s) + for s in scopes) + scopes = list(scopes) + + if self.is_nested_import(): + scopes.append(self.get_nested_import(scope)) + else: + scopes = [ImportPath.GlobalNamespace] + debug.dbg('after import', scopes) + + evaluate.follow_statement.pop_stmt() + return scopes + + def _follow_file_system(self): + """ + Find a module with a path (of the module, like usb.backend.libusb10). + """ + def follow_str(ns, string): + debug.dbg('follow_module', ns, string) + path = None + if ns: + path = ns[1] + elif self.import_stmt.relative_count: + module = self.import_stmt.get_parent_until() + path = os.path.abspath(module.path) + for i in range(self.import_stmt.relative_count): + path = os.path.dirname(path) + + global imports_processed + imports_processed += 1 + if path is not None: + return imp.find_module(string, [path]) + else: + debug.dbg('search_module', string, self.file_path) + # Override the sys.path. It works only good that way. + # Injecting the path directly into `find_module` did not work. + sys.path, temp = sys_path_mod, sys.path + try: + i = imp.find_module(string) + except ImportError: + sys.path = temp + raise + sys.path = temp + return i + + if self.file_path: + sys_path_mod = list(self.sys_path_with_modifications()) + sys_path_mod.insert(0, self.file_path) + else: + sys_path_mod = list(builtin.get_sys_path()) + + current_namespace = None + # now execute those paths + rest = [] + for i, s in enumerate(self.import_path): + try: + current_namespace = follow_str(current_namespace, s) + except ImportError: + if current_namespace: + rest = self.import_path[i:] + else: + raise ModuleNotFound( + 'The module you searched has not been found') + + sys_path_mod.pop(0) # TODO why is this here? + path = current_namespace[1] + is_package_directory = current_namespace[2][2] == imp.PKG_DIRECTORY + + f = None + if is_package_directory or current_namespace[0]: + # is a directory module + if is_package_directory: + path += '/__init__.py' + with open(path) as f: + source = f.read() + else: + source = current_namespace[0].read() + current_namespace[0].close() + if path.endswith('.py'): + f = modules.Module(path, source) + else: + f = builtin.Parser(path=path) + else: + f = builtin.Parser(name=path) + + return f.parser.module, rest + + +def strip_imports(scopes): + """ + Here we strip the imports - they don't get resolved necessarily. + Really used anymore? Merge with remove_star_imports? + """ + result = [] + for s in scopes: + if isinstance(s, parsing.Import): + result += ImportPath(s).follow() + else: + result.append(s) + return result + + +def cache_star_import(func): + def wrapper(scope, *args, **kwargs): + try: + mods = star_import_cache[scope] + if mods[0] + settings.star_import_cache_validity > time.time(): + return mods[1] + except KeyError: + pass + # cache is too old and therefore invalid or not available + invalidate_star_import_cache(scope) + mods = func(scope, *args, **kwargs) + star_import_cache[scope] = time.time(), mods + + return mods + return wrapper + + +def invalidate_star_import_cache(module, only_main=False): + """ Important if some new modules are being reparsed """ + try: + t, mods = star_import_cache[module] + + del star_import_cache[module] + + for m in mods: + invalidate_star_import_cache(m, only_main=True) + except KeyError: + pass + + if not only_main: + # We need a list here because otherwise the list is being changed + # during the iteration in py3k: iteritems -> items. + for key, (t, mods) in list(star_import_cache.items()): + if module in mods: + invalidate_star_import_cache(key) + + +@cache_star_import +def remove_star_imports(scope, ignored_modules=[]): + """ + Check a module for star imports: + >>> from module import * + + and follow these modules. + """ + modules = strip_imports(i for i in scope.get_imports() if i.star) + new = [] + for m in modules: + if m not in ignored_modules: + new += remove_star_imports(m, modules) + modules += new + + # Filter duplicate modules. + return set(modules) diff --git a/common/.local/lib/python2.7/site-packages/jedi/keywords.py b/common/.local/lib/python2.7/site-packages/jedi/keywords.py new file mode 100644 index 0000000..950270b --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/keywords.py @@ -0,0 +1,86 @@ +import keyword + +from _compatibility import is_py3k +import builtin + +import pydoc +try: + from pydoc_data import topics as pydoc_topics +except ImportError: + # Python 2.6 + try: + import pydoc_topics + except ImportError: + # Python 2.5 + pydoc_topics = None + +if is_py3k: + keys = keyword.kwlist +else: + keys = keyword.kwlist + ['None', 'False', 'True'] + + +def get_keywords(string='', pos=(0, 0), all=False): + if all: + return set([Keyword(k, pos) for k in keys]) + if string in keys: + return set([Keyword(string, pos)]) + return set() + + +def get_operator(string, pos): + return Keyword(string, pos) + + +class Keyword(object): + def __init__(self, name, pos): + self.name = name + self.start_pos = pos + self.parent = builtin.Builtin.scope + + def get_parent_until(self): + return self.parent + + @property + def names(self): + """ For a `parsing.Name` like comparision """ + return [self.name] + + @property + def docstr(self): + return imitate_pydoc(self.name) + + def __repr__(self): + return '<%s: %s>' % (type(self).__name__, self.name) + + +def imitate_pydoc(string): + """ + It's not possible to get the pydoc's without starting the annoying pager + stuff. + """ + # str needed because of possible unicode stuff in py2k (pydoc doesn't work + # with unicode strings) + string = str(string) + h = pydoc.help + try: + # try to access symbols + string = h.symbols[string] + string, _, related = string.partition(' ') + except KeyError: + pass + + get_target = lambda s: h.topics.get(s, h.keywords.get(s)) + while isinstance(string, str): + string = get_target(string) + + try: + # is a tuple now + label, related = string + except TypeError: + return '' + + try: + return pydoc_topics.topics[label] if pydoc_topics else '' + except KeyError: + return '' diff --git a/common/.local/lib/python2.7/site-packages/jedi/mixin/_functools.pym b/common/.local/lib/python2.7/site-packages/jedi/mixin/_functools.pym new file mode 100644 index 0000000..be8470f --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/mixin/_functools.pym @@ -0,0 +1,9 @@ +class partial(): + def __init__(self, func, *args, **keywords): + self.__func = func + self.__args = args + self.__keywords = keywords + + def __call__(self, *args, **kwargs): + # I know this doesn't work in Python, but Jedi can this ;-) + return self.__func(*self.__args, *args, **self.keywords, **kwargs) diff --git a/common/.local/lib/python2.7/site-packages/jedi/mixin/_sre.pym b/common/.local/lib/python2.7/site-packages/jedi/mixin/_sre.pym new file mode 100644 index 0000000..2b6935b --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/mixin/_sre.pym @@ -0,0 +1,99 @@ +def compile(): + class SRE_Match(): + endpos = 1 + lastgroup = 0 + lastindex = 1 + pos = 0 + string = 'a' + regs = ((0, 1),) + + def __init__(self, pattern): + self.re = pattern + + def start(self): + return 0 + + def end(self): + return 1 + + def span(self): + return 0, 1 + + def expand(self): + return '' + + def group(self): + return '' + + def groupdict(self): + return {'a', 'a'} + + def groups(self): + return ('a',) + + class SRE_Pattern(): + flags = 0 + groupindex = {} + groups = 0 + pattern = 'a' + + def findall(self): + """ + findall(string[, pos[, endpos]]) --> list. + Return a list of all non-overlapping matches of pattern in string. + """ + return ['a'] + + def finditer(self): + """ + finditer(string[, pos[, endpos]]) --> iterator. + Return an iterator over all non-overlapping matches for the + RE pattern in string. For each match, the iterator returns a + match object. + """ + yield SRE_Match(self) + + def match(self): + """ + match(string[, pos[, endpos]]) --> match object or None. + Matches zero or more characters at the beginning of the string + pattern + """ + return SRE_Match(self) + + def scanner(self): + pass + + def search(self): + """ + search(string[, pos[, endpos]]) --> match object or None. + Scan through string looking for a match, and return a corresponding + MatchObject instance. Return None if no position in the string matches. + """ + return SRE_Match(self) + + def split(self): + """ + split(string[, maxsplit = 0]) --> list. + Split string by the occurrences of pattern. + """ + return ['a'] + + def sub(self): + """ + sub(repl, string[, count = 0]) --> newstring + Return the string obtained by replacing the leftmost non-overlapping + occurrences of pattern in string by the replacement repl. + """ + return '' + + def subn(self): + """ + subn(repl, string[, count = 0]) --> (newstring, number of subs) + Return the tuple (new_string, number_of_subs_made) found by replacing + the leftmost non-overlapping occurrences of pattern with the + replacement repl. + """ + return ('', 1) + + return SRE_Pattern() diff --git a/common/.local/lib/python2.7/site-packages/jedi/mixin/_weakref.pym b/common/.local/lib/python2.7/site-packages/jedi/mixin/_weakref.pym new file mode 100644 index 0000000..05eab2c --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/mixin/_weakref.pym @@ -0,0 +1,8 @@ +def proxy(object, callback=None): + return object + +class ref(): + def __init__(self, object, callback=None): + self.__object = object + def __call__(self): + return self.__object diff --git a/common/.local/lib/python2.7/site-packages/jedi/mixin/builtins.pym b/common/.local/lib/python2.7/site-packages/jedi/mixin/builtins.pym new file mode 100644 index 0000000..28ddedf --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/mixin/builtins.pym @@ -0,0 +1,218 @@ +""" +Pure Python implementation of some builtins. +This code is not going to be executed anywhere. +These implementations are not always correct, but should work as good as +possible for the auto completion. +""" + + +def next(iterator, default=None): + if hasattr("next"): + return iterator.next() + else: + return iterator.__next__() + return default + + +def iter(collection, sentinel=None): + if sentinel: + yield collection() + else: + for c in collection: + yield c + + +def range(start, stop=None, step=1): + return [0] + + +class xrange(): + # Attention: this function doesn't exist in Py3k (there it is range). + def __iter__(self): + yield 1 + + def count(self): + return 1 + + def index(self): + return 1 + + +#-------------------------------------------------------- +# descriptors +#-------------------------------------------------------- +class property(): + def __init__(self, fget, fset=None, fdel=None, doc=None): + self.fget = fget + self.fset = fset + self.fdel = fdel + self.__doc__ = doc + + def __get__(self, obj, cls): + return self.fget(obj) + + def __set__(self, obj, value): + self.fset(obj, value) + + def __delete__(self, obj): + self.fdel(obj) + + def setter(self, func): + self.fset = func + return self + + def getter(self, func): + self.fget = func + return self + + def deleter(self, func): + self.fdel = func + return self + + +class staticmethod(): + def __init__(self, func): + self.__func = func + + def __get__(self, obj, cls): + return self.__func + + +class classmethod(): + def __init__(self, func): + self.__func = func + + def __get__(self, obj, cls): + def _method(*args, **kwargs): + return self.__func(cls, *args, **kwargs) + return _method + + +#-------------------------------------------------------- +# array stuff +#-------------------------------------------------------- +class list(): + def __init__(self, iterable=[]): + self.__iterable = [] + for i in iterable: + self.__iterable += [i] + + def __iter__(self): + for i in self.__iterable: + yield i + + def __getitem__(self, y): + return self.__iterable[y] + + def pop(self): + return self.__iterable[-1] + + +class tuple(): + def __init__(self, iterable=[]): + self.__iterable = [] + for i in iterable: + self.__iterable += [i] + + def __iter__(self): + for i in self.__iterable: + yield i + + def __getitem__(self, y): + return self.__iterable[y] + + def index(self): + return 1 + + def count(self): + return 1 + + +class set(): + def __init__(self, iterable=[]): + self.__iterable = iterable + + def __iter__(self): + for i in self.__iterable: + yield i + + def pop(self): + return self.__iterable.pop() + + def copy(self): + return self + + def difference(self, other): + return self - other + + def intersection(self, other): + return self & other + + def symmetric_difference(self, other): + return self ^ other + + def union(self, other): + return self | other + + +class frozenset(): + def __init__(self, iterable=[]): + self.__iterable = iterable + + def __iter__(self): + for i in self.__iterable: + yield i + + def copy(self): + return self + + +class dict(): + def __init__(self, **elements): + self.__elements = elements + + def clear(self): + # has a strange docstr + pass + + def get(self, k, d=None): + # TODO implement + try: + #return self.__elements[k] + pass + except KeyError: + return d + + +class reversed(): + def __init__(self, sequence): + self.__sequence = sequence + + def __iter__(self): + for i in self.__sequence: + yield i + + def __next__(self): + return next(self.__iter__()) + + def next(self): + return self.__next__() + + +#-------------------------------------------------------- +# basic types +#-------------------------------------------------------- +class int(): + def __init__(self, x, base=None): + pass + + +class str(): + def __init__(self, obj): + pass + +class object(): + def mro(): + """ mro() -> list + return a type's method resolution order """ + return [object] diff --git a/common/.local/lib/python2.7/site-packages/jedi/mixin/datetime.pym b/common/.local/lib/python2.7/site-packages/jedi/mixin/datetime.pym new file mode 100644 index 0000000..823ac5b --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/mixin/datetime.pym @@ -0,0 +1,4 @@ +class datetime(): + @staticmethod + def now(): + return datetime() diff --git a/common/.local/lib/python2.7/site-packages/jedi/mixin/posix.pym b/common/.local/lib/python2.7/site-packages/jedi/mixin/posix.pym new file mode 100644 index 0000000..4417f7c --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/mixin/posix.pym @@ -0,0 +1,5 @@ +def getcwd(): + return '' + +def getcwdu(): + return '' diff --git a/common/.local/lib/python2.7/site-packages/jedi/modules.py b/common/.local/lib/python2.7/site-packages/jedi/modules.py new file mode 100644 index 0000000..2421e91 --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/modules.py @@ -0,0 +1,312 @@ +from __future__ import with_statement + +from _compatibility import exec_function + +import re +import tokenize +import sys +import os +import time + +import parsing +import builtin +import debug +import evaluate +import settings +import imports + + +class Module(builtin.CachedModule): + """ + Manages all files, that are parsed and caches them. + + :param path: The module path of the file. + :param source: The source code of the file. + """ + def __init__(self, path, source): + super(Module, self).__init__(path=path) + self.source = source + self._line_cache = None + + def _get_source(self): + """ Just one time """ + s = self.source + del self.source # memory efficiency + return s + + +class ModuleWithCursor(Module): + """ + Manages all files, that are parsed and caches them. + Important are the params source and path, one of them has to + be there. + + :param source: The source code of the file. + :param path: The module path of the file or None. + :param position: The position, the user is currently in. Only important \ + for the main file. + """ + def __init__(self, path, source, position): + super(ModuleWithCursor, self).__init__(path, source) + self.position = position + + # this two are only used, because there is no nonlocal in Python 2 + self._line_temp = None + self._relevant_temp = None + + self.source = source + self._part_parser = None + + @property + def parser(self): + """ get the parser lazy """ + if not self._parser: + try: + ts, parser = builtin.CachedModule.cache[self.path] + imports.invalidate_star_import_cache(parser.module) + + del builtin.CachedModule.cache[self.path] + except KeyError: + pass + # Call the parser already here, because it will be used anyways. + # Also, the position is here important (which will not be used by + # default), therefore fill the cache here. + self._parser = parsing.PyFuzzyParser(self.source, self.path, + self.position) + if self.path is not None: + builtin.CachedModule.cache[self.path] = time.time(), \ + self._parser + return self._parser + + def get_path_until_cursor(self): + """ Get the path under the cursor. """ + result = self._get_path_until_cursor() + self._start_cursor_pos = self._line_temp + 1, self._column_temp + return result + + def _get_path_until_cursor(self, start_pos=None): + def fetch_line(): + line = self.get_line(self._line_temp) + if self._is_first: + self._is_first = False + self._line_length = self._column_temp + line = line[:self._column_temp] + else: + self._line_length = len(line) + line = line + '\n' + # add lines with a backslash at the end + while 1: + self._line_temp -= 1 + last_line = self.get_line(self._line_temp) + if last_line and last_line[-1] == '\\': + line = last_line[:-1] + ' ' + line + else: + break + return line[::-1] + + self._is_first = True + if start_pos is None: + self._line_temp = self.position[0] + self._column_temp = self.position[1] + else: + self._line_temp, self._column_temp = start_pos + + open_brackets = ['(', '[', '{'] + close_brackets = [')', ']', '}'] + + gen = tokenize.generate_tokens(fetch_line) + string = '' + level = 0 + force_point = False + try: + for token_type, tok, start, end, line in gen: + #print 'tok', token_type, tok, force_point + if level > 0: + if tok in close_brackets: + level += 1 + if tok in open_brackets: + level -= 1 + elif tok == '.': + force_point = False + elif force_point: + # it is reversed, therefore a number is getting recognized + # as a floating point number + if token_type == tokenize.NUMBER and tok[0] == '.': + force_point = False + else: + break + elif tok in close_brackets: + level += 1 + elif token_type in [tokenize.NAME, tokenize.STRING]: + force_point = True + elif token_type == tokenize.NUMBER: + pass + else: + break + + self._column_temp = self._line_length - end[1] + string += tok + except tokenize.TokenError: + debug.warning("Tokenize couldn't finish", sys.exc_info) + + return string[::-1] + + def get_path_under_cursor(self): + """ + Return the path under the cursor. If there is a rest of the path left, + it will be added to the stuff before it. + """ + line = self.get_line(self.position[0]) + after = re.search("[\w\d]*", line[self.position[1]:]).group(0) + return self.get_path_until_cursor() + after + + def get_operator_under_cursor(self): + line = self.get_line(self.position[0]) + after = re.match("[^\w\s]+", line[self.position[1]:]) + before = re.match("[^\w\s]+", line[:self.position[1]][::-1]) + return (before.group(0) if before is not None else '') \ + + (after.group(0) if after is not None else '') + + def get_context(self): + pos = self._start_cursor_pos + while pos > (1, 0): + # remove non important white space + line = self.get_line(pos[0]) + while pos[1] > 0 and line[pos[1] - 1].isspace(): + pos = pos[0], pos[1] - 1 + + try: + yield self._get_path_until_cursor(start_pos=pos) + except StopIteration: + yield '' + pos = self._line_temp, self._column_temp + + while True: + yield '' + + def get_line(self, line_nr): + if not self._line_cache: + self._line_cache = self.source.split('\n') + + if line_nr == 0: + # This is a fix for the zeroth line. We need a newline there, for + # the backwards parser. + return '' + if line_nr < 0: + raise StopIteration() + try: + return self._line_cache[line_nr - 1] + except IndexError: + raise StopIteration() + + def get_part_parser(self): + """ Returns a parser that contains only part of the source code. This + exists only because of performance reasons. + """ + if self._part_parser: + return self._part_parser + + # TODO check for docstrings + length = settings.part_line_length + offset = max(self.position[0] - length, 0) + s = '\n'.join(self.source.split('\n')[offset:offset + length]) + self._part_parser = parsing.PyFuzzyParser(s, self.path, self.position, + line_offset=offset) + return self._part_parser + + +@evaluate.memoize_default([]) +def sys_path_with_modifications(module): + def execute_code(code): + c = "import os; from os.path import *; result=%s" + variables = {'__file__': module.path} + try: + exec_function(c % code, variables) + except Exception: + debug.warning('sys path detected, but failed to evaluate') + return None + try: + res = variables['result'] + if isinstance(res, str): + return os.path.abspath(res) + else: + return None + except KeyError: + return None + + def check_module(module): + try: + possible_stmts = module.used_names['path'] + except KeyError: + return builtin.get_sys_path() + + sys_path = list(builtin.get_sys_path()) # copy + for p in possible_stmts: + try: + call = p.get_assignment_calls().get_only_subelement() + except AttributeError: + continue + n = call.name + if not isinstance(n, parsing.Name) or len(n.names) != 3: + continue + if n.names[:2] != ('sys', 'path'): + continue + array_cmd = n.names[2] + if call.execution is None: + continue + exe = call.execution + if not (array_cmd == 'insert' and len(exe) == 2 + or array_cmd == 'append' and len(exe) == 1): + continue + + if array_cmd == 'insert': + exe_type, exe.type = exe.type, parsing.Array.NOARRAY + exe_pop = exe.values.pop(0) + res = execute_code(exe.get_code()) + if res is not None: + sys_path.insert(0, res) + debug.dbg('sys path inserted: %s' % res) + exe.type = exe_type + exe.values.insert(0, exe_pop) + elif array_cmd == 'append': + res = execute_code(exe.get_code()) + if res is not None: + sys_path.append(res) + debug.dbg('sys path added: %s' % res) + return sys_path + + if module.path is None: + return [] # support for modules without a path is intentionally bad. + + curdir = os.path.abspath(os.curdir) + try: + os.chdir(os.path.dirname(module.path)) + except OSError: + pass + + result = check_module(module) + result += detect_django_path(module.path) + + # cleanup, back to old directory + os.chdir(curdir) + return result + + +def detect_django_path(module_path): + """ Detects the path of the very well known Django library (if used) """ + result = [] + while True: + new = os.path.dirname(module_path) + # If the module_path doesn't change anymore, we're finished -> / + if new == module_path: + break + else: + module_path = new + + try: + with open(module_path + os.path.sep + 'manage.py'): + debug.dbg('Found django path: %s' % module_path) + result.append(module_path) + except IOError: + pass + return result diff --git a/common/.local/lib/python2.7/site-packages/jedi/parsing.py b/common/.local/lib/python2.7/site-packages/jedi/parsing.py new file mode 100644 index 0000000..d56f7ae --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/parsing.py @@ -0,0 +1,1855 @@ +""" +Maintainer: David Halter +Version: 0.1 + +py_fuzzyparser parses python code, with the goal of a good representation of +the code within a tree structure. Variables, Classes and Functions are defined +within this tree structure, containing their exact locations in the code. +It is also a primary goal to work with code which contains syntax errors. + +This behaviour may be used to refactor, modify, search and complete code. + +To understand this code it is extremely important to understand the behaviour +of the python module 'tokenize'. + +This original codebase of this parser, which has been refactored and heavily +changed, was programmed by Aaron Griffin . + +**The structure of the following script:** +A Scope has + - imports (Import) + - subscopes (Scope, Class, Function, Flow) + - statements (Statement) + +All these objects have `Name`s. `Call` and `Array` are used as detail objects +of a statement. + +All those classes are being generated by PyFuzzyParser, which takes python text +as input and ignores just all the non-python stuff. Basically you could feed it +a perl script, and it should still work (which means throw no error. +""" +from _compatibility import (next, literal_eval, StringIO, + property, cleandoc, Python3Method) + +import tokenize +import re +import keyword +import os + +import debug + + +class ParserError(Exception): + pass + + +def indent_block(text, indention=' '): + """ This function indents a text block with a default of four spaces """ + temp = '' + while text and text[-1] == '\n': + temp += text[-1] + text = text[:-1] + lines = text.split('\n') + return '\n'.join(map(lambda s: indention + s, lines)) + temp + + +class PushBackIterator(object): + def __init__(self, iterator): + self.pushes = [] + self.iterator = iterator + + def push_back(self, value): + self.pushes.append(value) + + def __iter__(self): + return self + + def next(self): + """ Python 2 Compatibility """ + return self.__next__() + + def __next__(self): + if self.pushes: + return self.pushes.pop() + else: + return next(self.iterator) + + +class Base(object): + """ + This is just here to have an isinstance check, which is also used on + evaluate classes. But since they have sometimes a special type of + delegation, it is important for those classes to override this method. + + I know that there is a chance to do such things with __instancecheck__, but + since Python 2.5 doesn't support it, I decided to do it this way. + """ + def isinstance(self, *cls): + return isinstance(self, cls) + + +class Simple(Base): + """ + The super class for Scope, Import, Name and Statement. Every object in + the parser tree inherits from this class. + """ + def __init__(self, start_pos, end_pos=(None, None)): + self.start_pos = start_pos + self.end_pos = end_pos + self.parent = None + + @Python3Method + def get_parent_until(self, classes=(), reverse=False, + include_current=False): + """ Takes always the parent, until one class (not a Class) """ + if type(classes) not in (tuple, list): + classes = (classes,) + scope = self + while scope.parent is not None: + if classes and reverse != scope.isinstance(*classes): + if include_current: + return scope + break + scope = scope.parent + return scope + + def __repr__(self): + code = self.get_code().replace('\n', ' ') + return "<%s: %s@%s>" % \ + (type(self).__name__, code, self.start_pos[0]) + + +class Scope(Simple): + """ + Super class for the parser tree, which represents the state of a python + text file. + A Scope manages and owns its subscopes, which are classes and functions, as + well as variables and imports. It is used to access the structure of python + files. + + :param start_pos: The position (line and column) of the scope. + :type start_pos: tuple(int, int) + :param docstr: The docstring for the current Scope. + :type docstr: str + """ + def __init__(self, start_pos, docstr=''): + super(Scope, self).__init__(start_pos) + self.subscopes = [] + self.imports = [] + self.statements = [] + self.docstr = docstr + self.asserts = [] + + def add_scope(self, sub, decorators): + sub.parent = self + sub.decorators = decorators + for d in decorators: + # the parent is the same, because the decorator has not the scope + # of the function + d.parent = sub.parent + self.subscopes.append(sub) + return sub + + def add_statement(self, stmt): + """ + Used to add a Statement or a Scope. + A statement would be a normal command (Statement) or a Scope (Flow). + """ + stmt.parent = self + self.statements.append(stmt) + return stmt + + def add_docstr(self, string): + """ Clean up a docstring """ + self.docstr = cleandoc(literal_eval(string)) + + def add_import(self, imp): + self.imports.append(imp) + imp.parent = self + + def get_imports(self): + """ Gets also the imports within flow statements """ + i = [] + self.imports + for s in self.statements: + if isinstance(s, Scope): + i += s.get_imports() + return i + + def get_code(self, first_indent=False, indention=' '): + """ + :return: Returns the code of the current scope. + :rtype: str + """ + string = "" + if len(self.docstr) > 0: + string += '"""' + self.docstr + '"""\n' + for i in self.imports: + string += i.get_code() + for sub in self.subscopes: + string += sub.get_code(first_indent=True, indention=indention) + for stmt in self.statements: + string += stmt.get_code() + + if first_indent: + string = indent_block(string, indention=indention) + return string + + @Python3Method + def get_set_vars(self): + """ + Get all the names, that are active and accessible in the current + scope. + + :return: list of Name + :rtype: list + """ + n = [] + for stmt in self.statements: + try: + n += stmt.get_set_vars(True) + except TypeError: + n += stmt.get_set_vars() + + # function and class names + n += [s.name for s in self.subscopes] + + for i in self.imports: + if not i.star: + n += i.get_defined_names() + return n + + def get_defined_names(self): + return [n for n in self.get_set_vars() + if isinstance(n, Import) or len(n) == 1] + + def is_empty(self): + """ + :return: True if there are no subscopes, imports and statements. + :rtype: bool + """ + return not (self.imports or self.subscopes or self.statements) + + @Python3Method + def get_statement_for_position(self, pos): + checks = self.statements + self.asserts + if self.isinstance(Function): + checks += self.params + self.decorators + self.returns + for s in checks: + if isinstance(s, Flow): + p = s.get_statement_for_position(pos) + while s.next and not p: + s = s.next + p = s.get_statement_for_position(pos) + if p: + return p + elif s.start_pos <= pos < s.end_pos: + return s + + for s in self.subscopes: + if s.start_pos <= pos <= s.end_pos: + p = s.get_statement_for_position(pos) + if p: + return p + + def __repr__(self): + try: + name = self.path + except AttributeError: + try: + name = self.name + except AttributeError: + name = self.command + + return "<%s: %s@%s-%s>" % (type(self).__name__, name, + self.start_pos[0], self.end_pos[0]) + + +class Module(Scope): + """ + The top scope, which is always a module. + """ + def __init__(self, path, docstr=''): + super(Module, self).__init__((1, 0), docstr) + self.path = path + self.global_vars = [] + self._name = None + self.used_names = {} + self.temp_used_names = [] + + def add_global(self, name): + """ + Global means in these context a function (subscope) which has a global + statement. + This is only relevant for the top scope. + + :param name: The name of the global. + :type name: Name + """ + self.global_vars.append(name) + # set no parent here, because globals are not defined in this scope. + + def get_set_vars(self): + n = super(Module, self).get_set_vars() + n += self.global_vars + return n + + @property + def name(self): + """ This is used for the goto function. """ + if self._name is not None: + return self._name + if self.path is None: + string = '' # no path -> empty name + else: + sep = (re.escape(os.path.sep),) * 2 + r = re.search(r'([^%s]*?)(%s__init__)?(\.py|\.so)?$' % sep, + self.path) + string = r.group(1) + names = [(string, (0, 0))] + self._name = Name(names, self.start_pos, self.end_pos, self) + return self._name + + def is_builtin(self): + return not (self.path is None or self.path.endswith('.py')) + + +class Class(Scope): + """ + Used to store the parsed contents of a python class. + + :param name: The Class name. + :type name: string + :param supers: The super classes of a Class. + :type supers: list + :param start_pos: The start position (line, column) of the class. + :type start_pos: tuple(int, int) + :param docstr: The docstring for the current Scope. + :type docstr: str + """ + def __init__(self, name, supers, start_pos, docstr=''): + super(Class, self).__init__(start_pos, docstr) + self.name = name + name.parent = self + self.supers = supers + for s in self.supers: + s.parent = self + self.decorators = [] + + def get_code(self, first_indent=False, indention=' '): + string = "\n".join('@' + stmt.get_code() for stmt in self.decorators) + string += 'class %s' % (self.name) + if len(self.supers) > 0: + sup = ','.join(stmt.code for stmt in self.supers) + string += '(%s)' % sup + string += ':\n' + string += super(Class, self).get_code(True, indention) + if self.is_empty(): + string += "pass\n" + return string + + +class Function(Scope): + """ + Used to store the parsed contents of a python function. + + :param name: The Function name. + :type name: string + :param params: The parameters (Statement) of a Function. + :type params: list + :param start_pos: The start position (line, column) the Function. + :type start_pos: tuple(int, int) + :param docstr: The docstring for the current Scope. + :type docstr: str + """ + def __init__(self, name, params, start_pos, annotation): + Scope.__init__(self, start_pos) + self.name = name + name.parent = self + self.params = params + for p in params: + p.parent = self + p.parent_function = self + self.decorators = [] + self.returns = [] + self.is_generator = False + self.listeners = set() # not used here, but in evaluation. + + if annotation is not None: + annotation.parent = self + self.annotation = annotation + + def get_code(self, first_indent=False, indention=' '): + string = "\n".join('@' + stmt.get_code() for stmt in self.decorators) + params = ','.join([stmt.code for stmt in self.params]) + string += "def %s(%s):\n" % (self.name, params) + string += super(Function, self).get_code(True, indention) + if self.is_empty(): + string += "pass\n" + return string + + def get_set_vars(self): + n = super(Function, self).get_set_vars() + for p in self.params: + try: + n.append(p.get_name()) + except IndexError: + debug.warning("multiple names in param %s" % n) + return n + + def get_call_signature(self, width=72): + """ + Generate call signature of this function. + + :param width: Fold lines if a line is longer than this value. + :type width: int + + :rtype: str + """ + l = self.name.names[-1] + '(' + lines = [] + for (i, p) in enumerate(self.params): + code = p.get_code(False) + if i != len(self.params) - 1: + code += ', ' + if len(l + code) > width: + lines.append(l[:-1] if l[-1] == ' ' else l) + l = code + else: + l += code + if l: + lines.append(l) + lines[-1] += ')' + return '\n'.join(lines) + + @property + def doc(self): + """ Return a document string including call signature. """ + return '%s\n\n%s' % (self.get_call_signature(), self.docstr) + + +class Flow(Scope): + """ + Used to describe programming structure - flow statements, + which indent code, but are not classes or functions: + + - for + - while + - if + - try + - with + + Therefore statements like else, except and finally are also here, + they are now saved in the root flow elements, but in the next variable. + + :param command: The flow command, if, while, else, etc. + :type command: str + :param inits: The initializations of a flow -> while 'statement'. + :type inits: list(Statement) + :param start_pos: Position (line, column) of the Flow statement. + :type start_pos: tuple(int, int) + :param set_vars: Local variables used in the for loop (only there). + :type set_vars: list + """ + def __init__(self, command, inits, start_pos, set_vars=None): + self.next = None + self.command = command + super(Flow, self).__init__(start_pos, '') + self._parent = None + # These have to be statements, because of with, which takes multiple. + self.inits = inits + for s in inits: + s.parent = self + if set_vars is None: + self.set_vars = [] + else: + self.set_vars = set_vars + for s in self.set_vars: + s.parent.parent = self + s.parent = self + + @property + def parent(self): + return self._parent + + @parent.setter + def parent(self, value): + self._parent = value + if self.next: + self.next.parent = value + + def get_code(self, first_indent=False, indention=' '): + stmts = [] + for s in self.inits: + stmts.append(s.get_code(new_line=False)) + stmt = ', '.join(stmts) + string = "%s %s:\n" % (self.command, vars, stmt) + string += super(Flow, self).get_code(True, indention) + if self.next: + string += self.next.get_code() + return string + + def get_set_vars(self, is_internal_call=False): + """ + Get the names for the flow. This includes also a call to the super + class. + :param is_internal_call: defines an option for internal files to crawl\ + through this class. Normally it will just call its superiors, to\ + generate the output. + """ + if is_internal_call: + n = list(self.set_vars) + for s in self.inits: + n += s.set_vars + if self.next: + n += self.next.get_set_vars(is_internal_call) + n += super(Flow, self).get_set_vars() + return n + else: + return self.get_parent_until((Class, Function)).get_set_vars() + + def get_imports(self): + i = super(Flow, self).get_imports() + if self.next: + i += self.next.get_imports() + return i + + def set_next(self, next): + """ Set the next element in the flow, those are else, except, etc. """ + if self.next: + return self.next.set_next(next) + else: + self.next = next + self.next.parent = self.parent + return next + + +class ForFlow(Flow): + """ + Used for the for loop, because there are two statement parts. + """ + def __init__(self, inits, start_pos, set_stmt, is_list_comp=False): + super(ForFlow, self).__init__('for', inits, start_pos, + set_stmt.used_vars) + self.set_stmt = set_stmt + self.is_list_comp = is_list_comp + + def get_code(self, first_indent=False, indention=" " * 4): + vars = ",".join(x.get_code() for x in self.set_vars) + stmts = [] + for s in self.inits: + stmts.append(s.get_code(new_line=False)) + stmt = ', '.join(stmts) + s = "for %s in %s:\n" % (vars, stmt) + return s + super(Flow, self).get_code(True, indention) + + +class Import(Simple): + """ + Stores the imports of any Scopes. + + >>> 1+1 + 2 + + :param start_pos: Position (line, column) of the Import. + :type start_pos: tuple(int, int) + :param namespace: The import, can be empty if a star is given + :type namespace: Name + :param alias: The alias of a namespace(valid in the current namespace). + :type alias: Name + :param from_ns: Like the namespace, can be equally used. + :type from_ns: Name + :param star: If a star is used -> from time import *. + :type star: bool + :param defunct: An Import is valid or not. + :type defunct: bool + """ + def __init__(self, start_pos, end_pos, namespace, alias=None, + from_ns=None, star=False, relative_count=0, defunct=False): + super(Import, self).__init__(start_pos, end_pos) + + self.namespace = namespace + self.alias = alias + self.from_ns = from_ns + for n in [namespace, alias, from_ns]: + if n: + n.parent = self + + self.star = star + self.relative_count = relative_count + self.defunct = defunct + + def get_code(self, new_line=True): + # in case one of the names is None + alias = self.alias or '' + namespace = self.namespace or '' + from_ns = self.from_ns or '' + + if self.alias: + ns_str = "%s as %s" % (namespace, alias) + else: + ns_str = str(namespace) + + nl = '\n' if new_line else '' + if self.from_ns or self.relative_count: + if self.star: + ns_str = '*' + dots = '.' * self.relative_count + return "from %s%s import %s%s" % (dots, from_ns, ns_str, nl) + else: + return "import %s%s" % (ns_str, nl) + + def get_defined_names(self): + if self.defunct: + return [] + if self.star: + return [self] + if self.alias: + return [self.alias] + if len(self.namespace) > 1: + o = self.namespace + n = Name([(o.names[0], o.start_pos)], o.start_pos, o.end_pos, + parent=o.parent) + return [n] + else: + return [self.namespace] + + def get_set_vars(self): + return self.get_defined_names() + + def get_all_import_names(self): + n = [] + if self.from_ns: + n.append(self.from_ns) + if self.namespace: + n.append(self.namespace) + if self.alias: + n.append(self.alias) + return n + + +class Statement(Simple): + """ + This is the class for all the possible statements. Which means, this class + stores pretty much all the Python code, except functions, classes, imports, + and flow functions like if, for, etc. + + :param code: The full code of a statement. This is import, if one wants \ + to execute the code at some level. + :param code: str + :param set_vars: The variables which are defined by the statement. + :param set_vars: str + :param used_funcs: The functions which are used by the statement. + :param used_funcs: str + :param used_vars: The variables which are used by the statement. + :param used_vars: str + :param token_list: Token list which is also peppered with Name. + :param token_list: list + :param start_pos: Position (line, column) of the Statement. + :type start_pos: tuple(int, int) + """ + def __init__(self, code, set_vars, used_funcs, used_vars, token_list, + start_pos, end_pos): + super(Statement, self).__init__(start_pos, end_pos) + self.code = code + self.used_funcs = used_funcs + self.used_vars = used_vars + self.token_list = token_list + for s in set_vars + used_funcs + used_vars: + s.parent = self + self.set_vars = self._remove_executions_from_set_vars(set_vars) + + # cache + self._assignment_calls = None + self._assignment_details = None + # this is important for other scripts + self._assignment_calls_calculated = False + + def _remove_executions_from_set_vars(self, set_vars): + """ + Important mainly for assosiative arrays: + + >>> a = 3 + >>> b = {} + >>> b[a] = 3 + + `a` is in this case not a set_var, it is used to index the dict. + """ + + if not set_vars: + return set_vars + result = set(set_vars) + last = None + in_execution = 0 + for tok in self.token_list: + if isinstance(tok, Name): + if tok not in result: + break + if in_execution: + result.remove(tok) + elif isinstance(tok, tuple): + tok = tok[1] + if tok in ['(', '['] and isinstance(last, Name): + in_execution += 1 + elif tok in [')', ']'] and in_execution > 0: + in_execution -= 1 + last = tok + return list(result) + + def get_code(self, new_line=True): + if new_line: + return self.code + '\n' + else: + return self.code + + def get_set_vars(self): + """ Get the names for the statement. """ + return list(self.set_vars) + + @property + def assignment_details(self): + if self._assignment_details is None: + # normally, this calls sets this variable + self.get_assignment_calls() + # it may not have been set by get_assignment_calls -> just use an empty + # array + return self._assignment_details or [] + + def is_global(self): + # first keyword of the first token is global -> must be a global + return str(self.token_list[0]) == "global" + + def get_assignment_calls(self): + """ + This is not done in the main parser, because it might be slow and + most of the statements won't need this data anyway. This is something + 'like' a lazy execution. + + This is not really nice written, sorry for that. If you plan to replace + it and make it nicer, that would be cool :-) + """ + if self._assignment_calls_calculated: + return self._assignment_calls + self._assignment_details = [] + top = result = Array(self.start_pos, Array.NOARRAY, self) + level = 0 + is_chain = False + close_brackets = False + + tok_iter = enumerate(self.token_list) + for i, tok_temp in tok_iter: + #print 'tok', tok_temp, result + if isinstance(tok_temp, ListComprehension): + result.add_to_current_field(tok_temp) + continue + try: + token_type, tok, start_pos = tok_temp + except TypeError: + # the token is a Name, which has already been parsed + tok = tok_temp + token_type = None + start_pos = tok.start_pos + except ValueError: + debug.warning("unkown value, shouldn't happen", + tok_temp, type(tok_temp)) + raise + else: + if tok in ['return', 'yield'] or level == 0 and \ + tok.endswith('=') and not tok in ['>=', '<=', '==', '!=']: + # This means, there is an assignment here. + + # Add assignments, which can be more than one + self._assignment_details.append((tok, top)) + # All these calls wouldn't be important if nonlocal would + # exist. -> Initialize the first item again. + result = Array(start_pos, Array.NOARRAY, self) + top = result + level = 0 + close_brackets = False + is_chain = False + continue + elif tok == 'as': + next(tok_iter, None) + continue + + brackets = {'(': Array.TUPLE, '[': Array.LIST, '{': Array.SET} + is_call = lambda: type(result) == Call + is_call_or_close = lambda: is_call() or close_brackets + + is_literal = token_type in [tokenize.STRING, tokenize.NUMBER] + if isinstance(tok, Name) or is_literal: + c_type = Call.NAME + if is_literal: + tok = literal_eval(tok) + if token_type == tokenize.STRING: + c_type = Call.STRING + elif token_type == tokenize.NUMBER: + c_type = Call.NUMBER + + if is_chain: + call = Call(tok, c_type, start_pos, parent=result) + result = result.set_next_chain_call(call) + is_chain = False + close_brackets = False + else: + if close_brackets: + result = result.parent + close_brackets = False + if type(result) == Call: + result = result.parent + call = Call(tok, c_type, start_pos, parent=result) + result.add_to_current_field(call) + result = call + elif tok in brackets.keys(): # brackets + level += 1 + if is_call_or_close(): + result = Array(start_pos, brackets[tok], parent=result) + result = result.parent.add_execution(result) + close_brackets = False + else: + result = Array(start_pos, brackets[tok], parent=result) + result.parent.add_to_current_field(result) + elif tok == ':': + while is_call_or_close(): + result = result.parent + close_brackets = False + if result.type == Array.LIST: # [:] lookups + result.add_to_current_field(tok) + else: + result.add_dictionary_key() + elif tok == '.': + if close_brackets and result.parent != top: + # only get out of the array, if it is a array execution + result = result.parent + close_brackets = False + is_chain = True + elif tok == ',': + while is_call_or_close(): + result = result.parent + close_brackets = False + result.add_field((start_pos[0], start_pos[1] + 1)) + # important - it cannot be empty anymore + if result.type == Array.NOARRAY: + result.type = Array.TUPLE + elif tok in [')', '}', ']']: + while is_call_or_close(): + result = result.parent + close_brackets = False + if tok == '}' and not len(result): + # this is a really special case - empty brackets {} are + # always dictionaries and not sets. + result.type = Array.DICT + level -= 1 + result.end_pos = start_pos[0], start_pos[1] + 1 + close_brackets = True + else: + while is_call_or_close(): + result = result.parent + close_brackets = False + if tok != '\n': + result.add_to_current_field(tok) + + if level != 0: + debug.warning("Brackets don't match: %s." + "This is not normal behaviour." % level) + + self._assignment_calls_calculated = True + self._assignment_calls = top + return top + + +class Param(Statement): + """ + The class which shows definitions of params of classes and functions. + But this is not to define function calls. + """ + def __init__(self, code, set_vars, used_funcs, used_vars, + token_list, start_pos, end_pos): + super(Param, self).__init__(code, set_vars, used_funcs, used_vars, + token_list, start_pos, end_pos) + + # this is defined by the parser later on, not at the initialization + # it is the position in the call (first argument, second...) + self.position_nr = None + self.is_generated = False + self.annotation_stmt = None + self.parent_function = None + + def add_annotation(self, annotation_stmt): + annotation_stmt.parent = self + self.annotation_stmt = annotation_stmt + + def get_name(self): + """ get the name of the param """ + n = self.set_vars or self.used_vars + if len(n) > 1: + debug.warning("Multiple param names (%s)." % n) + return n[0] + + +class Call(Base): + """ + `Call` contains a call, e.g. `foo.bar` and owns the executions of those + calls, which are `Array`s. + """ + NAME = 1 + NUMBER = 2 + STRING = 3 + + def __init__(self, name, type, start_pos, parent_stmt=None, parent=None): + self.name = name + # parent is not the oposite of next. The parent of c: a = [b.c] would + # be an array. + self.parent = parent + self.type = type + self.start_pos = start_pos + + self.next = None + self.execution = None + self._parent_stmt = parent_stmt + + @property + def parent_stmt(self): + if self._parent_stmt is not None: + return self._parent_stmt + elif self.parent: + return self.parent.parent_stmt + else: + return None + + @parent_stmt.setter + def parent_stmt(self, value): + self._parent_stmt = value + + def set_next_chain_call(self, call): + """ Adds another part of the statement""" + self.next = call + call.parent = self.parent + return call + + def add_execution(self, call): + """ + An execution is nothing else than brackets, with params in them, which + shows access on the internals of this name. + """ + self.execution = call + # there might be multiple executions, like a()[0], in that case, they + # have the same parent. Otherwise it's not possible to parse proper. + if self.parent.execution == self: + call.parent = self.parent + else: + call.parent = self + return call + + def generate_call_path(self): + """ Helps to get the order in which statements are executed. """ + # TODO include previous nodes? As an option? + try: + for name_part in self.name.names: + yield name_part + except AttributeError: + yield self + if self.execution is not None: + for y in self.execution.generate_call_path(): + yield y + if self.next is not None: + for y in self.next.generate_call_path(): + yield y + + def get_code(self): + if self.type == Call.NAME: + s = self.name.get_code() + else: + s = repr(self.name) + if self.execution is not None: + s += '(%s)' % self.execution.get_code() + if self.next is not None: + s += self.next.get_code() + return s + + def __repr__(self): + return "<%s: %s>" % \ + (type(self).__name__, self.name) + + +class Array(Call): + """ + Describes the different python types for an array, but also empty + statements. In the Python syntax definitions this type is named 'atom'. + http://docs.python.org/py3k/reference/grammar.html + Array saves sub-arrays as well as normal operators and calls to methods. + + :param array_type: The type of an array, which can be one of the constants\ + below. + :type array_type: int + """ + NOARRAY = None + TUPLE = 'tuple' + LIST = 'list' + DICT = 'dict' + SET = 'set' + + def __init__(self, start_pos, arr_type=NOARRAY, parent_stmt=None, + parent=None, values=None): + super(Array, self).__init__(None, arr_type, start_pos, parent_stmt, + parent) + + self.values = values if values else [] + self.arr_el_pos = [] + self.keys = [] + self.end_pos = None + + def add_field(self, start_pos): + """ + Just add a new field to the values. + + Each value has a sub-array, because there may be different tokens in + one array. + """ + self.arr_el_pos.append(start_pos) + self.values.append([]) + + def add_to_current_field(self, tok): + """ Adds a token to the latest field (in content). """ + if not self.values: + # An empty round brace is just a tuple, filled it is unnecessary. + if self.type == Array.TUPLE: + self.type = Array.NOARRAY + # Add the first field, this is done here, because if nothing + # gets added, the list is empty, which is also needed sometimes. + self.values.append([]) + self.values[-1].append(tok) + + def add_dictionary_key(self): + """ + Only used for dictionaries, automatically adds the tokens added by now + from the values to keys, because the parser works this way. + """ + if self.type in (Array.LIST, Array.TUPLE): + return # these are basically code errors, just ignore + self.keys.append(self.values.pop()) + if self.type == Array.SET: + self.type = Array.DICT + self.values.append([]) + + def get_only_subelement(self): + """ + Returns the only element that an array contains. If it contains + more than one element, raise an exception. + """ + if len(self.values) != 1 or len(self.values[0]) != 1: + raise AttributeError("More than one value found") + return self.values[0][0] + + @staticmethod + def is_type(instance, *types): + """ + This is not only used for calls on the actual object, but for + ducktyping, to invoke this function with anything as `self`. + """ + if isinstance(instance, Array): + if instance.type in types: + return True + return False + + def __len__(self): + return len(self.values) + + def __getitem__(self, key): + return self.values[key] + + def __iter__(self): + if self.type == self.DICT: + return iter(zip(self.keys, self.values)) + else: + return iter(self.values) + + def get_code(self): + def to_str(el): + try: + return el.get_code() + except AttributeError: + return str(el) + + map = {Array.NOARRAY: '%s', + Array.TUPLE: '(%s)', + Array.LIST: '[%s]', + Array.DICT: '{%s}', + Array.SET: '{%s}' + } + inner = [] + for i, value in enumerate(self.values): + s = '' + try: + key = self.keys[i] + except IndexError: + pass + else: + for el in key[i]: + s += to_str(el) + for el in value: + s += to_str(el) + inner.append(s) + return map[self.type] % ', '.join(inner) + + def __repr__(self): + if self.type == self.NOARRAY: + typ = 'noarray' + else: + typ = self.type + return "<%s: %s%s>" % (type(self).__name__, typ, self.values) + + +class NamePart(str): + """ + A string. Sometimes it is important to know if the string belongs to a name + or not. + """ + def __new__(cls, s, start_pos): + self = super(NamePart, cls).__new__(cls, s) + self.start_pos = start_pos + return self + + @property + def end_pos(self): + return self.start_pos[0], self.start_pos[1] + len(self) + + +class Name(Simple): + """ + Used to define names in python. + Which means the whole namespace/class/function stuff. + So a name like "module.class.function" + would result in an array of [module, class, function] + """ + def __init__(self, names, start_pos, end_pos, parent=None): + super(Name, self).__init__(start_pos, end_pos) + self.names = tuple(n if isinstance(n, NamePart) else NamePart(*n) + for n in names) + if parent is not None: + self.parent = parent + + def get_code(self): + """ Returns the names in a full string format """ + return ".".join(self.names) + + def __str__(self): + return self.get_code() + + def __len__(self): + return len(self.names) + + +class ListComprehension(object): + """ Helper class for list comprehensions """ + def __init__(self, stmt, middle, input): + self.stmt = stmt + self.middle = middle + self.input = input + + def __repr__(self): + return "<%s: %s>" % \ + (type(self).__name__, self.get_code()) + + def get_code(self): + statements = self.stmt, self.middle, self.input + code = [s.get_code().replace('\n', '') for s in statements] + return "%s for %s in %s" % tuple(code) + + +class PyFuzzyParser(object): + """ + This class is used to parse a Python file, it then divides them into a + class structure of different scopes. + + :param code: The codebase for the parser. + :type code: str + :param user_position: The line/column, the user is currently on. + :type user_position: tuple(int, int) + """ + def __init__(self, code, module_path=None, user_position=None, + no_docstr=False, line_offset=0): + self.user_position = user_position + self.user_scope = None + self.user_stmt = None + self.code = code + '\n' # end with \n, because the parser needs it + self.no_docstr = no_docstr + + # initialize global Scope + self.module = Module(module_path) + self.scope = self.module + self.current = (None, None) + + # Stuff to fix tokenize errors. The parser is pretty good in tolerating + # any errors of tokenize and just parse ahead. + self._line_of_tokenize_restart = line_offset + + self.parse() + + # delete code again, only the parser needs it + del self.code + + def __repr__(self): + return "<%s: %s>" % (type(self).__name__, self.module) + + @property + def start_pos(self): + return (self._line_of_tokenize_restart + self._tokenize_start_pos[0], + self._tokenize_start_pos[1]) + + @property + def end_pos(self): + return (self._line_of_tokenize_restart + self._tokenize_end_pos[0], + self._tokenize_end_pos[1]) + + def _check_user_stmt(self, simple): + if not isinstance(simple, Param): + for tok_name in self.module.temp_used_names: + try: + self.module.used_names[tok_name].add(simple) + except KeyError: + self.module.used_names[tok_name] = set([simple]) + self.module.temp_used_names = [] + + if not self.user_position: + return + # the position is right + if simple.start_pos <= self.user_position <= simple.end_pos: + if self.user_stmt is not None: + # if there is already a user position (another import, because + # imports are splitted) the names are checked. + for n in simple.get_set_vars(): + if n.start_pos < self.user_position <= n.end_pos: + self.user_stmt = simple + else: + self.user_stmt = simple + + def _parsedotname(self, pre_used_token=None): + """ + The dot name parser parses a name, variable or function and returns + their names. + + :return: Tuple of Name, token_type, nexttoken. + :rtype: tuple(Name, int, str) + """ + def append(el): + names.append(el) + self.module.temp_used_names.append(el[0]) + + names = [] + if pre_used_token is None: + token_type, tok = self.next() + if token_type != tokenize.NAME and tok != '*': + return [], token_type, tok + else: + token_type, tok = pre_used_token + + if token_type != tokenize.NAME and tok != '*': + # token maybe a name or star + return None, token_type, tok + + append((tok, self.start_pos)) + first_pos = self.start_pos + while True: + token_type, tok = self.next() + if tok != '.': + break + token_type, tok = self.next() + if token_type != tokenize.NAME: + break + append((tok, self.start_pos)) + + n = Name(names, first_pos, self.end_pos) if names else None + return n, token_type, tok + + def _parseimportlist(self): + """ + The parser for the imports. Unlike the class and function parse + function, this returns no Import class, but rather an import list, + which is then added later on. + The reason, why this is not done in the same class lies in the nature + of imports. There are two ways to write them: + + - from ... import ... + - import ... + + To distinguish, this has to be processed after the parser. + + :return: List of imports. + :rtype: list + """ + imports = [] + brackets = False + continue_kw = [",", ";", "\n", ')'] \ + + list(set(keyword.kwlist) - set(['as'])) + while True: + defunct = False + token_type, tok = self.next() + if token_type == tokenize.ENDMARKER: + break + if brackets and tok == '\n': + self.next() + if tok == '(': # python allows only one `(` in the statement. + brackets = True + self.next() + i, token_type, tok = self._parsedotname(self.current) + if not i: + defunct = True + name2 = None + if tok == 'as': + name2, token_type, tok = self._parsedotname() + imports.append((i, name2, defunct)) + while tok not in continue_kw: + token_type, tok = self.next() + if not (tok == "," or brackets and tok == '\n'): + break + return imports + + def _parseparen(self): + """ + Functions and Classes have params (which means for classes + super-classes). They are parsed here and returned as Statements. + + :return: List of Statements + :rtype: list + """ + names = [] + tok = None + pos = 0 + breaks = [',', ':'] + while tok not in [')', ':']: + param, tok = self._parse_statement(added_breaks=breaks, + stmt_class=Param) + if param and tok == ':': + # parse annotations + annotation, tok = self._parse_statement(added_breaks=breaks) + if annotation: + param.add_annotation(annotation) + + # params without vars are usually syntax errors. + if param and (param.set_vars or param.used_vars): + param.position_nr = pos + names.append(param) + pos += 1 + + return names + + def _parsefunction(self): + """ + The parser for a text functions. Process the tokens, which follow a + function definition. + + :return: Return a Scope representation of the tokens. + :rtype: Function + """ + first_pos = self.start_pos + token_type, fname = self.next() + if token_type != tokenize.NAME: + return None + + fname = Name([(fname, self.start_pos)], self.start_pos, self.end_pos) + + token_type, open = self.next() + if open != '(': + return None + params = self._parseparen() + + token_type, colon = self.next() + annotation = None + if colon in ['-', '->']: + # parse annotations + if colon == '-': + # The Python 2 tokenizer doesn't understand this + token_type, colon = self.next() + if colon != '>': + return None + annotation, colon = self._parse_statement(added_breaks=[':']) + + if colon != ':': + return None + + # because of 2 line func param definitions + scope = Function(fname, params, first_pos, annotation) + if self.user_scope and scope != self.user_scope \ + and self.user_position > first_pos: + self.user_scope = scope + return scope + + def _parseclass(self): + """ + The parser for a text class. Process the tokens, which follow a + class definition. + + :return: Return a Scope representation of the tokens. + :rtype: Class + """ + first_pos = self.start_pos + token_type, cname = self.next() + if token_type != tokenize.NAME: + debug.warning("class: syntax err, token is not a name@%s (%s: %s)" + % (self.start_pos[0], tokenize.tok_name[token_type], cname)) + return None + + cname = Name([(cname, self.start_pos)], self.start_pos, self.end_pos) + + super = [] + token_type, next = self.next() + if next == '(': + super = self._parseparen() + token_type, next = self.next() + + if next != ':': + debug.warning("class syntax: %s@%s" % (cname, self.start_pos[0])) + return None + + # because of 2 line class initializations + scope = Class(cname, super, first_pos) + if self.user_scope and scope != self.user_scope \ + and self.user_position > first_pos: + self.user_scope = scope + return scope + + def _parse_statement(self, pre_used_token=None, added_breaks=None, + stmt_class=Statement, list_comp=False): + """ + Parses statements like: + + >>> a = test(b) + >>> a += 3 - 2 or b + + and so on. One line at a time. + + :param pre_used_token: The pre parsed token. + :type pre_used_token: set + :return: Statement + last parsed token. + :rtype: (Statement, str) + """ + + string = '' + set_vars = [] + used_funcs = [] + used_vars = [] + level = 0 # The level of parentheses + is_return = None + + if pre_used_token: + token_type, tok = pre_used_token + else: + token_type, tok = self.next() + + while token_type == tokenize.COMMENT: + # remove newline and comment + self.next() + token_type, tok = self.next() + + first_pos = self.start_pos + opening_brackets = ['{', '(', '['] + closing_brackets = ['}', ')', ']'] + + # the difference between "break" and "always break" is that the latter + # will even break in parentheses. This is true for typical flow + # commands like def and class and the imports, which will never be used + # in a statement. + breaks = ['\n', ':', ')'] + always_break = [';', 'import', 'from', 'class', 'def', 'try', 'except', + 'finally', 'while'] + if added_breaks: + breaks += added_breaks + + tok_list = [] + while not (tok in always_break or tok in breaks and level <= 0): + try: + set_string = None + #print 'parse_stmt', tok, tokenize.tok_name[token_type] + tok_list.append(self.current + (self.start_pos,)) + if tok == 'as': + string += " %s " % tok + token_type, tok = self.next() + if token_type == tokenize.NAME: + n, token_type, tok = self._parsedotname(self.current) + if n: + set_vars.append(n) + tok_list.append(n) + string += ".".join(n.names) + continue + elif token_type == tokenize.NAME: + if tok in ['return', 'yield', 'del', 'raise']: + if len(tok_list) > 1: + # this happens, when a statement has opening + # brackets, which are not closed again, here I just + # start a new statement. This is a hack, but I + # could not come up with a better solution. + # This is basically a reset of the statement. + debug.warning('keyword in statement %s@%s', + tok_list, self.start_pos[0]) + tok_list = [self.current + (self.start_pos,)] + set_vars = [] + used_funcs = [] + used_vars = [] + level = 0 + set_string = tok + ' ' + if tok in ['return', 'yield']: + is_return = tok + elif tok == 'for': + # list comprehensions! + middle, tok = self._parse_statement( + added_breaks=['in']) + if tok != 'in' or middle is None: + if middle is None: + level -= 1 + else: + middle.parent = self.scope + debug.warning('list comprehension formatting @%s' % + self.start_pos[0]) + continue + + b = [')', ']'] + in_clause, tok = self._parse_statement(added_breaks=b, + list_comp=True) + if tok not in b or in_clause is None: + middle.parent = self.scope + if in_clause is None: + self.gen.push_back(self._current_full) + else: + in_clause.parent = self.scope + in_clause.parent = self.scope + debug.warning('list comprehension in_clause %s@%s' + % (tok, self.start_pos[0])) + continue + other_level = 0 + + for i, tok in enumerate(reversed(tok_list)): + if not isinstance(tok, (Name, ListComprehension)): + tok = tok[1] + if tok in closing_brackets: + other_level -= 1 + elif tok in opening_brackets: + other_level += 1 + if other_level > 0: + break + else: + # could not detect brackets -> nested list comp + i = 0 + + tok_list, toks = tok_list[:-i], tok_list[-i:-1] + src = '' + for t in toks: + src += t[1] if isinstance(t, tuple) \ + else t.get_code() + st = Statement(src, [], [], [], + toks, first_pos, self.end_pos) + + for s in [st, middle, in_clause]: + s.parent = self.scope + tok = ListComprehension(st, middle, in_clause) + tok_list.append(tok) + if list_comp: + string = '' + string += tok.get_code() + continue + else: + n, token_type, tok = self._parsedotname(self.current) + # removed last entry, because we add Name + tok_list.pop() + if n: + tok_list.append(n) + if tok == '(': + # it must be a function + used_funcs.append(n) + else: + used_vars.append(n) + if string and re.match(r'[\w\d\'"]', string[-1]): + string += ' ' + string += ".".join(n.names) + continue + elif tok.endswith('=') and tok not in ['>=', '<=', '==', '!=']: + # there has been an assignement -> change vars + if level == 0: + set_vars += used_vars + used_vars = [] + elif tok in opening_brackets: + level += 1 + elif tok in closing_brackets: + level -= 1 + + string = set_string if set_string is not None else string + tok + token_type, tok = self.next() + except StopIteration: + # comes from tokenizer + break + + if not string: + return None, tok + #print 'new_stat', string, set_vars, used_funcs, used_vars + if self.freshscope and not self.no_docstr and len(tok_list) == 1 \ + and self.last_token[0] == tokenize.STRING: + self.scope.add_docstr(self.last_token[1]) + return None, tok + else: + stmt = stmt_class(string, set_vars, used_funcs, used_vars, + tok_list, first_pos, self.end_pos) + self._check_user_stmt(stmt) + if is_return: + # add returns to the scope + func = self.scope.get_parent_until(Function) + if is_return == 'yield': + func.is_generator = True + try: + func.returns.append(stmt) + except AttributeError: + debug.warning('return in non-function') + + if tok in always_break: + self.gen.push_back(self._current_full) + return stmt, tok + + def next(self): + return self.__next__() + + def __iter__(self): + return self + + def __next__(self): + """ Generate the next tokenize pattern. """ + try: + self._current_full = next(self.gen) + except tokenize.TokenError: + # We just ignore this error, I try to handle it earlier - as + # good as possible + debug.warning('parentheses not closed error') + except IndentationError: + # This is an error, that tokenize may produce, because the code + # is not indented as it should. Here it just ignores this line + # and restarts the parser. + # (This is a rather unlikely error message, for normal code, + # tokenize seems to be pretty tolerant) + debug.warning('indentation error on line %s, ignoring it' % + (self.start_pos[0])) + self._line_of_tokenize_restart = self.start_pos[0] + 1 + self.gen = PushBackIterator(tokenize.generate_tokens( + self.buf.readline)) + return self.next() + except StopIteration: + # set end_pos correctly, if we finish + s = self.scope + while s is not None: + s.end_pos = self.end_pos + s = s.parent + raise + + type, tok, self._tokenize_start_pos, self._tokenize_end_pos, \ + self.parserline = self._current_full + if self.user_position and (self.start_pos[0] == self.user_position[0] + or self.user_scope is None + and self.start_pos[0] >= self.user_position[0]): + debug.dbg('user scope found [%s] = %s' % \ + (self.parserline.replace('\n', ''), repr(self.scope))) + self.user_scope = self.scope + self.last_token = self.current + self.current = (type, tok) + return self.current + + def parse(self): + """ + The main part of the program. It analyzes the given code-text and + returns a tree-like scope. For a more detailed description, see the + class description. + + :param text: The code which should be parsed. + :param type: str + + :raises: IndentationError + """ + self.buf = StringIO(self.code) + self.gen = PushBackIterator(tokenize.generate_tokens( + self.buf.readline)) + + extended_flow = ['else', 'elif', 'except', 'finally'] + statement_toks = ['{', '[', '(', '`'] + + decorators = [] + self.freshscope = True + self.iterator = iter(self) + # This iterator stuff is not intentional. It grew historically. + for token_type, tok in self.iterator: + self.module.temp_used_names = [] + #debug.dbg('main: tok=[%s] type=[%s] indent=[%s]'\ + # % (tok, tokenize.tok_name[token_type], start_position[0])) + + while token_type == tokenize.DEDENT and self.scope != self.module: + token_type, tok = self.next() + if self.start_pos[1] <= self.scope.start_pos[1]: + self.scope.end_pos = self.start_pos + self.scope = self.scope.parent + + # check again for unindented stuff. this is true for syntax + # errors. only check for names, because thats relevant here. If + # some docstrings are not indented, I don't care. + while self.start_pos[1] <= self.scope.start_pos[1] \ + and (token_type == tokenize.NAME or tok in ['(', '['])\ + and self.scope != self.module: + self.scope.end_pos = self.start_pos + self.scope = self.scope.parent + + first_pos = self.start_pos + if tok == 'def': + func = self._parsefunction() + if func is None: + debug.warning("function: syntax error@%s" % + self.start_pos[0]) + continue + self.freshscope = True + self.scope = self.scope.add_scope(func, decorators) + decorators = [] + elif tok == 'class': + cls = self._parseclass() + if cls is None: + debug.warning("class: syntax error@%s" % self.start_pos[0]) + continue + self.freshscope = True + self.scope = self.scope.add_scope(cls, decorators) + decorators = [] + # import stuff + elif tok == 'import': + imports = self._parseimportlist() + for m, alias, defunct in imports: + i = Import(first_pos, self.end_pos, m, alias, + defunct=defunct) + self._check_user_stmt(i) + self.scope.add_import(i) + if not imports: + i = Import(first_pos, self.end_pos, None, defunct=True) + self._check_user_stmt(i) + self.freshscope = False + elif tok == 'from': + defunct = False + # take care for relative imports + relative_count = 0 + while 1: + token_type, tok = self.next() + if tok != '.': + break + relative_count += 1 + # the from import + mod, token_type, tok = self._parsedotname(self.current) + if str(mod) == 'import' and relative_count: + self.gen.push_back(self._current_full) + tok = 'import' + mod = None + if not mod and not relative_count or tok != "import": + debug.warning("from: syntax error@%s" % self.start_pos[0]) + defunct = True + if tok != 'import': + self.gen.push_back(self._current_full) + names = self._parseimportlist() + for name, alias, defunct2 in names: + star = name is not None and name.names[0] == '*' + if star: + name = None + i = Import(first_pos, self.end_pos, name, alias, mod, + star, relative_count, defunct=defunct or defunct2) + self._check_user_stmt(i) + self.scope.add_import(i) + self.freshscope = False + #loops + elif tok == 'for': + set_stmt, tok = self._parse_statement(added_breaks=['in']) + if tok == 'in': + statement, tok = self._parse_statement() + if tok == ':': + s = [] if statement is None else [statement] + f = ForFlow(s, first_pos, set_stmt) + self.scope = self.scope.add_statement(f) + else: + debug.warning('syntax err, for flow started @%s', + self.start_pos[0]) + if statement is not None: + statement.parent = self.scope + if set_stmt is not None: + set_stmt.parent = self.scope + else: + debug.warning('syntax err, for flow incomplete @%s', + self.start_pos[0]) + if set_stmt is not None: + set_stmt.parent = self.scope + + elif tok in ['if', 'while', 'try', 'with'] + extended_flow: + added_breaks = [] + command = tok + if command in ['except', 'with']: + added_breaks.append(',') + # multiple statements because of with + inits = [] + first = True + while first or command == 'with' \ + and tok not in [':', '\n']: + statement, tok = \ + self._parse_statement(added_breaks=added_breaks) + if command == 'except' and tok in added_breaks: + # the except statement defines a var + # this is only true for python 2 + n, token_type, tok = self._parsedotname() + if n: + statement.set_vars.append(n) + statement.code += ',' + n.get_code() + if statement: + inits.append(statement) + first = False + + if tok == ':': + f = Flow(command, inits, first_pos) + if command in extended_flow: + # the last statement has to be another part of + # the flow statement, because a dedent releases the + # main scope, so just take the last statement. + try: + s = self.scope.statements[-1].set_next(f) + except (AttributeError, IndexError): + # If set_next doesn't exist, just add it. + s = self.scope.add_statement(f) + else: + s = self.scope.add_statement(f) + self.scope = s + else: + for i in inits: + i.parent = self.scope + debug.warning('syntax err, flow started @%s', + self.start_pos[0]) + # globals + elif tok == 'global': + stmt, tok = self._parse_statement(self.current) + if stmt: + self.scope.add_statement(stmt) + for name in stmt.used_vars: + # add the global to the top, because there it is + # important. + self.module.add_global(name) + # decorator + elif tok == '@': + stmt, tok = self._parse_statement() + decorators.append(stmt) + elif tok == 'pass': + continue + elif tok == 'assert': + stmt, tok = self._parse_statement() + stmt.parent = self.scope + self.scope.asserts.append(stmt) + # default + elif token_type in [tokenize.NAME, tokenize.STRING, + tokenize.NUMBER] \ + or tok in statement_toks: + # this is the main part - a name can be a function or a + # normal var, which can follow anything. but this is done + # by the statement parser. + stmt, tok = self._parse_statement(self.current) + if stmt: + self.scope.add_statement(stmt) + self.freshscope = False + else: + if token_type not in [tokenize.COMMENT, tokenize.INDENT, + tokenize.NEWLINE, tokenize.NL, + tokenize.ENDMARKER]: + debug.warning('token not classified', tok, token_type, + self.start_pos[0]) + + del self.buf + return self.module diff --git a/common/.local/lib/python2.7/site-packages/jedi/settings.py b/common/.local/lib/python2.7/site-packages/jedi/settings.py new file mode 100644 index 0000000..23f366d --- /dev/null +++ b/common/.local/lib/python2.7/site-packages/jedi/settings.py @@ -0,0 +1,87 @@ +# ---------------- +# completion output settings +# ---------------- + +# The completion is by default case insensitive. +case_insensitive_completion = True + +# Adds a dot after a module, because a module that is not accessed this way is +# definitely not the normal case. However, in VIM this doesn't work, that's why +# it isn't used at the moment. +add_dot_after_module = False + +# Adds an opening bracket after a function, because that's normal behaviour. +# Removed it again, because in VIM that is not very practical. +add_bracket_after_function = False + + +# ---------------- +# dynamic stuff +# ---------------- + +# check for `append`, etc. on array instances like list() +dynamic_arrays_instances = True +# check for `append`, etc. on arrays: [], {}, () +dynamic_array_additions = True + +# A dynamic param completion, finds the callees of the function, which define +# the params of a function. +dynamic_params = True +# Do the same for other modules. +dynamic_params_for_other_modules = True + +# Additional modules in which Jedi checks if statements are to be found. This +# is practical for IDE's, that want to administrate their modules themselves. +additional_dynamic_modules = [] + +# ---------------- +# recursions +# ---------------- + +# Recursion settings are important if you don't want extremly recursive python +# code to go absolutely crazy. First of there is a global limit +# `max_executions`. This limit is important, to set a maximum amount of time, +# the completion may use. +# +# The `max_until_execution_unique` limit is probably the most important one, +# because if that limit is passed, functions can only be one time executed. So +# new functions will be executed, complex recursions with the same functions +# again and again, are ignored. +# +# `max_function_recursion_level` is more about whether the recursions are +# stopped in deepth or in width. The ratio beetween this and +# `max_until_execution_unique` is important here. It stops a recursion (after +# the number of function calls in the recursion), if it was already used +# earlier. +# +# The values are based on my experimental tries, used on the jedi library. But +# I don't think there's any other Python library, that uses recursion in a +# similar (extreme) way. This makes the completion definitely worse in some +# cases. But a completion should also be fast. + +max_function_recursion_level = 5 +max_until_execution_unique = 50 +max_executions_without_builtins = 200 +max_executions = 250 + +# Because get_in_function_call is normally used on every single key hit, it has +# to be faster than a normal completion. This is the factor that is used to +# scale `max_executions` and `max_until_execution_unique`: +scale_get_in_function_call = 0.1 + +# ---------------- +# various +# ---------------- + +# Size of the current code part, which is used to speed up parsing. +part_line_length = 20 + +# ---------------- +# star import caching +# ---------------- + +# In huge packages like numpy, checking all star imports on every completion +# might be slow, therefore we do a star import caching, that lasts a certain +# time span (in seconds). + +star_import_cache_validity = 60.0 diff --git a/common/.local/lib/python2.7/site-packages/powerline/segments/vim.py b/common/.local/lib/python2.7/site-packages/powerline/segments/vim.py index 9e7a8b6..21dff03 100644 --- a/common/.local/lib/python2.7/site-packages/powerline/segments/vim.py +++ b/common/.local/lib/python2.7/site-packages/powerline/segments/vim.py @@ -184,7 +184,7 @@ def file_name(pl, segment_info, display_no_file=False, no_file_text='[No file]') }] else: return None - file_name = vim_funcs['fnamemodify'](name, ':~:.:t') + file_name = vim_funcs['fnamemodify'](name, ':~:.:t').decode('utf-8') return file_name diff --git a/common/.vim/bundle/nerdtree/.git/HEAD b/common/.vim/bundle/nerdtree/.git/HEAD deleted file mode 100644 index cb089cd..0000000 --- a/common/.vim/bundle/nerdtree/.git/HEAD +++ /dev/null @@ -1 +0,0 @@ -ref: refs/heads/master diff --git a/common/.vim/bundle/nerdtree/.git/config b/common/.vim/bundle/nerdtree/.git/config deleted file mode 100644 index bf20b6d..0000000 --- a/common/.vim/bundle/nerdtree/.git/config +++ /dev/null @@ -1,11 +0,0 @@ -[core] - repositoryformatversion = 0 - filemode = true - bare = false - logallrefupdates = true -[remote "origin"] - fetch = +refs/heads/*:refs/remotes/origin/* - url = https://github.com/scrooloose/nerdtree.git -[branch "master"] - remote = origin - merge = refs/heads/master diff --git a/common/.vim/bundle/nerdtree/.git/description b/common/.vim/bundle/nerdtree/.git/description deleted file mode 100644 index 498b267..0000000 --- a/common/.vim/bundle/nerdtree/.git/description +++ /dev/null @@ -1 +0,0 @@ -Unnamed repository; edit this file 'description' to name the repository. diff --git a/common/.vim/bundle/nerdtree/.git/hooks/applypatch-msg.sample b/common/.vim/bundle/nerdtree/.git/hooks/applypatch-msg.sample deleted file mode 100755 index 8b2a2fe..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/applypatch-msg.sample +++ /dev/null @@ -1,15 +0,0 @@ -#!/bin/sh -# -# An example hook script to check the commit log message taken by -# applypatch from an e-mail message. -# -# The hook should exit with non-zero status after issuing an -# appropriate message if it wants to stop the commit. The hook is -# allowed to edit the commit message file. -# -# To enable this hook, rename this file to "applypatch-msg". - -. git-sh-setup -test -x "$GIT_DIR/hooks/commit-msg" && - exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"} -: diff --git a/common/.vim/bundle/nerdtree/.git/hooks/commit-msg.sample b/common/.vim/bundle/nerdtree/.git/hooks/commit-msg.sample deleted file mode 100755 index b58d118..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/commit-msg.sample +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/sh -# -# An example hook script to check the commit log message. -# Called by "git commit" with one argument, the name of the file -# that has the commit message. The hook should exit with non-zero -# status after issuing an appropriate message if it wants to stop the -# commit. The hook is allowed to edit the commit message file. -# -# To enable this hook, rename this file to "commit-msg". - -# Uncomment the below to add a Signed-off-by line to the message. -# Doing this in a hook is a bad idea in general, but the prepare-commit-msg -# hook is more suited to it. -# -# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') -# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" - -# This example catches duplicate Signed-off-by lines. - -test "" = "$(grep '^Signed-off-by: ' "$1" | - sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { - echo >&2 Duplicate Signed-off-by lines. - exit 1 -} diff --git a/common/.vim/bundle/nerdtree/.git/hooks/post-update.sample b/common/.vim/bundle/nerdtree/.git/hooks/post-update.sample deleted file mode 100755 index ec17ec1..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/post-update.sample +++ /dev/null @@ -1,8 +0,0 @@ -#!/bin/sh -# -# An example hook script to prepare a packed repository for use over -# dumb transports. -# -# To enable this hook, rename this file to "post-update". - -exec git update-server-info diff --git a/common/.vim/bundle/nerdtree/.git/hooks/pre-applypatch.sample b/common/.vim/bundle/nerdtree/.git/hooks/pre-applypatch.sample deleted file mode 100755 index b1f187c..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/pre-applypatch.sample +++ /dev/null @@ -1,14 +0,0 @@ -#!/bin/sh -# -# An example hook script to verify what is about to be committed -# by applypatch from an e-mail message. -# -# The hook should exit with non-zero status after issuing an -# appropriate message if it wants to stop the commit. -# -# To enable this hook, rename this file to "pre-applypatch". - -. git-sh-setup -test -x "$GIT_DIR/hooks/pre-commit" && - exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"} -: diff --git a/common/.vim/bundle/nerdtree/.git/hooks/pre-commit.sample b/common/.vim/bundle/nerdtree/.git/hooks/pre-commit.sample deleted file mode 100755 index 18c4829..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/pre-commit.sample +++ /dev/null @@ -1,50 +0,0 @@ -#!/bin/sh -# -# An example hook script to verify what is about to be committed. -# Called by "git commit" with no arguments. The hook should -# exit with non-zero status after issuing an appropriate message if -# it wants to stop the commit. -# -# To enable this hook, rename this file to "pre-commit". - -if git rev-parse --verify HEAD >/dev/null 2>&1 -then - against=HEAD -else - # Initial commit: diff against an empty tree object - against=4b825dc642cb6eb9a060e54bf8d69288fbee4904 -fi - -# If you want to allow non-ascii filenames set this variable to true. -allownonascii=$(git config hooks.allownonascii) - -# Redirect output to stderr. -exec 1>&2 - -# Cross platform projects tend to avoid non-ascii filenames; prevent -# them from being added to the repository. We exploit the fact that the -# printable range starts at the space character and ends with tilde. -if [ "$allownonascii" != "true" ] && - # Note that the use of brackets around a tr range is ok here, (it's - # even required, for portability to Solaris 10's /usr/bin/tr), since - # the square bracket bytes happen to fall in the designated range. - test $(git diff --cached --name-only --diff-filter=A -z $against | - LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 -then - echo "Error: Attempt to add a non-ascii file name." - echo - echo "This can cause problems if you want to work" - echo "with people on other platforms." - echo - echo "To be portable it is advisable to rename the file ..." - echo - echo "If you know what you are doing you can disable this" - echo "check using:" - echo - echo " git config hooks.allownonascii true" - echo - exit 1 -fi - -# If there are whitespace errors, print the offending file names and fail. -exec git diff-index --check --cached $against -- diff --git a/common/.vim/bundle/nerdtree/.git/hooks/pre-rebase.sample b/common/.vim/bundle/nerdtree/.git/hooks/pre-rebase.sample deleted file mode 100755 index 33730ca..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/pre-rebase.sample +++ /dev/null @@ -1,169 +0,0 @@ -#!/bin/sh -# -# Copyright (c) 2006, 2008 Junio C Hamano -# -# The "pre-rebase" hook is run just before "git rebase" starts doing -# its job, and can prevent the command from running by exiting with -# non-zero status. -# -# The hook is called with the following parameters: -# -# $1 -- the upstream the series was forked from. -# $2 -- the branch being rebased (or empty when rebasing the current branch). -# -# This sample shows how to prevent topic branches that are already -# merged to 'next' branch from getting rebased, because allowing it -# would result in rebasing already published history. - -publish=next -basebranch="$1" -if test "$#" = 2 -then - topic="refs/heads/$2" -else - topic=`git symbolic-ref HEAD` || - exit 0 ;# we do not interrupt rebasing detached HEAD -fi - -case "$topic" in -refs/heads/??/*) - ;; -*) - exit 0 ;# we do not interrupt others. - ;; -esac - -# Now we are dealing with a topic branch being rebased -# on top of master. Is it OK to rebase it? - -# Does the topic really exist? -git show-ref -q "$topic" || { - echo >&2 "No such branch $topic" - exit 1 -} - -# Is topic fully merged to master? -not_in_master=`git rev-list --pretty=oneline ^master "$topic"` -if test -z "$not_in_master" -then - echo >&2 "$topic is fully merged to master; better remove it." - exit 1 ;# we could allow it, but there is no point. -fi - -# Is topic ever merged to next? If so you should not be rebasing it. -only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` -only_next_2=`git rev-list ^master ${publish} | sort` -if test "$only_next_1" = "$only_next_2" -then - not_in_topic=`git rev-list "^$topic" master` - if test -z "$not_in_topic" - then - echo >&2 "$topic is already up-to-date with master" - exit 1 ;# we could allow it, but there is no point. - else - exit 0 - fi -else - not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` - /usr/bin/perl -e ' - my $topic = $ARGV[0]; - my $msg = "* $topic has commits already merged to public branch:\n"; - my (%not_in_next) = map { - /^([0-9a-f]+) /; - ($1 => 1); - } split(/\n/, $ARGV[1]); - for my $elem (map { - /^([0-9a-f]+) (.*)$/; - [$1 => $2]; - } split(/\n/, $ARGV[2])) { - if (!exists $not_in_next{$elem->[0]}) { - if ($msg) { - print STDERR $msg; - undef $msg; - } - print STDERR " $elem->[1]\n"; - } - } - ' "$topic" "$not_in_next" "$not_in_master" - exit 1 -fi - -<<\DOC_END - -This sample hook safeguards topic branches that have been -published from being rewound. - -The workflow assumed here is: - - * Once a topic branch forks from "master", "master" is never - merged into it again (either directly or indirectly). - - * Once a topic branch is fully cooked and merged into "master", - it is deleted. If you need to build on top of it to correct - earlier mistakes, a new topic branch is created by forking at - the tip of the "master". This is not strictly necessary, but - it makes it easier to keep your history simple. - - * Whenever you need to test or publish your changes to topic - branches, merge them into "next" branch. - -The script, being an example, hardcodes the publish branch name -to be "next", but it is trivial to make it configurable via -$GIT_DIR/config mechanism. - -With this workflow, you would want to know: - -(1) ... if a topic branch has ever been merged to "next". Young - topic branches can have stupid mistakes you would rather - clean up before publishing, and things that have not been - merged into other branches can be easily rebased without - affecting other people. But once it is published, you would - not want to rewind it. - -(2) ... if a topic branch has been fully merged to "master". - Then you can delete it. More importantly, you should not - build on top of it -- other people may already want to - change things related to the topic as patches against your - "master", so if you need further changes, it is better to - fork the topic (perhaps with the same name) afresh from the - tip of "master". - -Let's look at this example: - - o---o---o---o---o---o---o---o---o---o "next" - / / / / - / a---a---b A / / - / / / / - / / c---c---c---c B / - / / / \ / - / / / b---b C \ / - / / / / \ / - ---o---o---o---o---o---o---o---o---o---o---o "master" - - -A, B and C are topic branches. - - * A has one fix since it was merged up to "next". - - * B has finished. It has been fully merged up to "master" and "next", - and is ready to be deleted. - - * C has not merged to "next" at all. - -We would want to allow C to be rebased, refuse A, and encourage -B to be deleted. - -To compute (1): - - git rev-list ^master ^topic next - git rev-list ^master next - - if these match, topic has not merged in next at all. - -To compute (2): - - git rev-list master..topic - - if this is empty, it is fully merged to "master". - -DOC_END diff --git a/common/.vim/bundle/nerdtree/.git/hooks/prepare-commit-msg.sample b/common/.vim/bundle/nerdtree/.git/hooks/prepare-commit-msg.sample deleted file mode 100755 index f093a02..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/prepare-commit-msg.sample +++ /dev/null @@ -1,36 +0,0 @@ -#!/bin/sh -# -# An example hook script to prepare the commit log message. -# Called by "git commit" with the name of the file that has the -# commit message, followed by the description of the commit -# message's source. The hook's purpose is to edit the commit -# message file. If the hook fails with a non-zero status, -# the commit is aborted. -# -# To enable this hook, rename this file to "prepare-commit-msg". - -# This hook includes three examples. The first comments out the -# "Conflicts:" part of a merge commit. -# -# The second includes the output of "git diff --name-status -r" -# into the message, just before the "git status" output. It is -# commented because it doesn't cope with --amend or with squashed -# commits. -# -# The third example adds a Signed-off-by line to the message, that can -# still be edited. This is rarely a good idea. - -case "$2,$3" in - merge,) - /usr/bin/perl -i.bak -ne 's/^/# /, s/^# #/#/ if /^Conflicts/ .. /#/; print' "$1" ;; - -# ,|template,) -# /usr/bin/perl -i.bak -pe ' -# print "\n" . `git diff --cached --name-status -r` -# if /^#/ && $first++ == 0' "$1" ;; - - *) ;; -esac - -# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') -# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" diff --git a/common/.vim/bundle/nerdtree/.git/hooks/update.sample b/common/.vim/bundle/nerdtree/.git/hooks/update.sample deleted file mode 100755 index 71ab04e..0000000 --- a/common/.vim/bundle/nerdtree/.git/hooks/update.sample +++ /dev/null @@ -1,128 +0,0 @@ -#!/bin/sh -# -# An example hook script to blocks unannotated tags from entering. -# Called by "git receive-pack" with arguments: refname sha1-old sha1-new -# -# To enable this hook, rename this file to "update". -# -# Config -# ------ -# hooks.allowunannotated -# This boolean sets whether unannotated tags will be allowed into the -# repository. By default they won't be. -# hooks.allowdeletetag -# This boolean sets whether deleting tags will be allowed in the -# repository. By default they won't be. -# hooks.allowmodifytag -# This boolean sets whether a tag may be modified after creation. By default -# it won't be. -# hooks.allowdeletebranch -# This boolean sets whether deleting branches will be allowed in the -# repository. By default they won't be. -# hooks.denycreatebranch -# This boolean sets whether remotely creating branches will be denied -# in the repository. By default this is allowed. -# - -# --- Command line -refname="$1" -oldrev="$2" -newrev="$3" - -# --- Safety check -if [ -z "$GIT_DIR" ]; then - echo "Don't run this script from the command line." >&2 - echo " (if you want, you could supply GIT_DIR then run" >&2 - echo " $0 )" >&2 - exit 1 -fi - -if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then - echo "Usage: $0 " >&2 - exit 1 -fi - -# --- Config -allowunannotated=$(git config --bool hooks.allowunannotated) -allowdeletebranch=$(git config --bool hooks.allowdeletebranch) -denycreatebranch=$(git config --bool hooks.denycreatebranch) -allowdeletetag=$(git config --bool hooks.allowdeletetag) -allowmodifytag=$(git config --bool hooks.allowmodifytag) - -# check for no description -projectdesc=$(sed -e '1q' "$GIT_DIR/description") -case "$projectdesc" in -"Unnamed repository"* | "") - echo "*** Project description file hasn't been set" >&2 - exit 1 - ;; -esac - -# --- Check types -# if $newrev is 0000...0000, it's a commit to delete a ref. -zero="0000000000000000000000000000000000000000" -if [ "$newrev" = "$zero" ]; then - newrev_type=delete -else - newrev_type=$(git cat-file -t $newrev) -fi - -case "$refname","$newrev_type" in - refs/tags/*,commit) - # un-annotated tag - short_refname=${refname##refs/tags/} - if [ "$allowunannotated" != "true" ]; then - echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2 - echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 - exit 1 - fi - ;; - refs/tags/*,delete) - # delete tag - if [ "$allowdeletetag" != "true" ]; then - echo "*** Deleting a tag is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/tags/*,tag) - # annotated tag - if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 - then - echo "*** Tag '$refname' already exists." >&2 - echo "*** Modifying a tag is not allowed in this repository." >&2 - exit 1 - fi - ;; - refs/heads/*,commit) - # branch - if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then - echo "*** Creating a branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/heads/*,delete) - # delete branch - if [ "$allowdeletebranch" != "true" ]; then - echo "*** Deleting a branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/remotes/*,commit) - # tracking branch - ;; - refs/remotes/*,delete) - # delete tracking branch - if [ "$allowdeletebranch" != "true" ]; then - echo "*** Deleting a tracking branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - *) - # Anything else (is there anything else?) - echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 - exit 1 - ;; -esac - -# --- Finished -exit 0 diff --git a/common/.vim/bundle/nerdtree/.git/index b/common/.vim/bundle/nerdtree/.git/index deleted file mode 100644 index 9f2de7c7141c5ed9a1b68eec46ecc7945fc1a8c9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1600 zcmZ?q402{*U|<4b!GO0*`T5IKgkUrS0|z66h4xPdhQ=if49qVen1Ro1#)0<*S})y2 zFUaiIxzr)L@QLR~1}?qy%#zIXy!@h6pjlu5GY3XP&HIIFp3s4Wwz;pi_%m&CJoZD> zz2KwTXUXng4E#Z^jxN5gdbx>3*(v$uc|a4v=4{q=fze>|yreo%&D-|x8LJ<2*;bL7 zXW}to=9@e&gxq}dj6pQ9v?M<#KQTo=FSRJ8q$o92uPiec?oMIObzt*BG}v4p**mD_ z-pX+Q?5?)Q^Fxto>s;lK*7hU!9;7)j2&UvG>-)I|xx|CbEU74gnB%tH2;@#-APqI| z9;$h4e$SU5HDV93d|1wTBIC>%haH@}t}|wkMmImL7;HK`G$7$DVs-l$ z$b1kDHs4PUm=y5hSo+28WAC`BNRR zxj-6f?lM$!HD>afZ>h*RaY-ZZuD0~G?2p_Rx49`W$Ux17IbT01KR+9kI1mnpnG2(# z<}XJzUsWsW&NRlz7}M{rTk>B|$}hBhe_)CWgEYGN$wjG&CHX}N<8irv1*-Y{GuvFt zf?CtgOP!AIy%Q~XFZ`0*6b(%Cvr{YMa}x^)o4*p(d=ZUxd@nqLA`44H^mf|ctM)AC zkmTCVpp5Q*P?CvH&d)0;%FoG3CBh%8Q0?J)kiYZh<2jz@u^K!3&bo6R{1Yiuv4=qx zt3B|v3Cd8g@Q2aRcvy{UzTCP!2d?~yQz&c;KYv+AW#N6#>$l~37^Kk6&o4*?#yL_j z;WB>>s`-9;5xW^JMELg1alEZuRPw4;WwyGx34;W>`2~q384%N9?uF4%cdtb?*H&3t zN?A7inN^{F@a3XZ)?IQs8xC%Et2lP0AJ%vKfSnEAvVcD= 1357751567 +0100 clone: from https://github.com/scrooloose/nerdtree.git diff --git a/common/.vim/bundle/nerdtree/.git/logs/refs/heads/master b/common/.vim/bundle/nerdtree/.git/logs/refs/heads/master deleted file mode 100644 index 2348d75..0000000 --- a/common/.vim/bundle/nerdtree/.git/logs/refs/heads/master +++ /dev/null @@ -1 +0,0 @@ -0000000000000000000000000000000000000000 c3b63d2fd9c929359231363bcabc880ba29eb96e Christophe Buffenoir 1357751567 +0100 clone: from https://github.com/scrooloose/nerdtree.git diff --git a/common/.vim/bundle/nerdtree/.git/logs/refs/remotes/origin/HEAD b/common/.vim/bundle/nerdtree/.git/logs/refs/remotes/origin/HEAD deleted file mode 100644 index 2348d75..0000000 --- a/common/.vim/bundle/nerdtree/.git/logs/refs/remotes/origin/HEAD +++ /dev/null @@ -1 +0,0 @@ -0000000000000000000000000000000000000000 c3b63d2fd9c929359231363bcabc880ba29eb96e Christophe Buffenoir 1357751567 +0100 clone: from https://github.com/scrooloose/nerdtree.git diff --git a/common/.vim/bundle/nerdtree/.git/objects/pack/pack-fabae269ee6a303f1bab5c4620044bd810e1771f.idx b/common/.vim/bundle/nerdtree/.git/objects/pack/pack-fabae269ee6a303f1bab5c4620044bd810e1771f.idx deleted file mode 100644 index b846f8ca243de76faed54210977aef8284f86d20..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 73172 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�hOt8IU-3drxdPx0{qwc}KnY62905Sy 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 diff --git a/common/.vim/bundle/nerdtree/.git/objects/pack/pack-fabae269ee6a303f1bab5c4620044bd810e1771f.pack b/common/.vim/bundle/nerdtree/.git/objects/pack/pack-fabae269ee6a303f1bab5c4620044bd810e1771f.pack deleted file mode 100644 index d2e331d5388f6135b404495666b7a58cd1d0e25b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1004643 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

wlQ7jSgx&x1?YK^V(?+ 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

g>Hq0~7JW-ES$ma0WpiMTX|o3n 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

    Mwif-LhoUrS5Ir7|AH2H zdKA0I44rjj7f(HjTs1Qo{L@d=eLFTEQUS16I!^^roK(V$`vf%Nm2HyH*F|^?X^K7^ zC~lKRmp}HzK%GkP;#AM&|&D!~%!?grWD5U@>6=g*jhF(=&DwdTLK!%#9c(WAOU^`Zb<_e}zcCRGILNgKP}<5FZECSdNJk-7;e3XfIk4q^=AK00q-5BMC=H zh|1OzxC1a=k~x6!Txh7MHy>^6Y_TgJ2z5Rv0E{OBZVq5PXy<i#~Z2$OT{V4;%JI_(xT4x35`ym5_?zV>| z`Q`2XSYvV(%wsF^$F1(UM$dv1z#>0P+3%t-Ibd!rLEP4K!n8sO>sw z<+unUILX3uACRl9BG|s26q4zyP5IGje-WE&+01Gj@0$STx$;OFW2@>+XrnU!G%h(_ zn77%9i*3tFRU^aH6mFxZXk!>2t?fq9jeuvXdnR+E2@A&)6+$?cw|$_l+6^V0r5m1v zccb^pIL>u&Q3PF*h#)ZeFjIZrnRGj5(Fbgl#Q=u5ejm7=`y&gLIm@AY)HSzhC3OaZ zW>FnG(_RnSlO@`p$2LwW&a&p!rw0yPZe+`h)fGiE;!CuV@8^6TA6Jwb&-`fj9X2dI z7uMOw?|Ug8?H>=YVO-v<-&Cek0QfeBEI;`QWOM8si25K${xm22lmAV;rTMy`cQ;3g zJeJmvKMvN4*UU$u%|bcSzFS|WiacKRo{Gf;0gRw-R<$Q$*$PXA9pM)>r^i?$)F_q; zabWNO)75b`VG0A_!SJHJ9#iJyn%(wbRQb#Mbpp7}t)jURs#0o6O#skB7M0NCQX7Oo z=b!TQGwuCsVPO+?1H8c-lkw#bJ>>m%W*n-jl>Mm|)>}0#c#?j^jL0|CtF|ht2*|M> z7VWk$thTu!S5aD8+n{f+#OO}tcq)bOt6|dn0DU9Gn^MwIDMd9LW2!A>V_;k+-4Rab zRQZ+2VzeQk|JcB&cm0@jx?nzc9j2!MV`z^oxM@U0MnB+Db@>og)P&H=bNPeN7wCr9YsiyBa8x zJLJ^)Tbd{cqDRQ3iFGIk2;L-A^AB8E;ba#iv7vgcNFy8C0UPbrC{eEsPz&1a+)CNo zwl94L)Wjmcs@gw1;i6veMC^xSm_x^(ubTQ>J}`k_4ZLDq4&$i1cs@?b&`v~xMHXY= zkSe;IBg2>4VcPF!JgeUiF;xoY0zGN#T0?JKn`2~gu%8(7*j+?_&gfrlMOX@WO3@J1HHkh&T{Akj(vjpCWd6=M>dRLhM1xBETYBs z4iy3XMlsc+#(L@_m8wK}MsL=G27z4QlSHo6Zf5WF!(G|WlvEA91=VPJ0ZKK0fWP7M zpycRx_-?u9FGWoC*OT23j~;U0r=;aKw)m5Sqo4}5cL(Wq3A-*Eqa<7z;$=JrDQ4v1l5iqBe`%&2bsJ`QXI<7SaBFHsHXti=SJ} zrz#pH4R6?68lMozmGt|-@DO$g9!4Bq7J%WZVtNpV@IJ(XD28`RqIa^ye2J$j6a8V8 zb9ct<%RKW{Vd@?l?e= zq9@3Ruib4Fy)wTjmH3qCT@vjQc}$V@+Ste!VQ2|z2#OdmGpbe(Q@6jiZozugwA%%Q z+d1ZM@p@Kq^p0ZhJMwYIX;RqOz<|SQ*TQ_MAt7Z_QW0*3M?|!kX0v4C+Rc5k-NLov zcJG*UF%wr*FSGN}hRpoMl+x$qbrPv7k!?4~Ysi2k0eyO?TU7L6crBag!jX?rN-O+E zUi(%e*W($x9iqXrzB6m!k62R#@=T(d)LtKEdj_Hf9jlAK7n^^%vRQOW2={^7TmT}& z+#WtXo&8}#@f6L+QSEUl!gQ^!s@70$&dx^z(NXB02Ciqi3^&L^cyrUOwnhX0TwyHm zj1URF1G)Fps-j^4(`q;;OKeO?;?4CLv$f};P}BEgPFL%sxC}4P2{qj_Uvcfkw3Y#5 zDp{1@!Y-;9euS^UY}_D12)Zx0lw6kIZp(Vy-t91~5)-XV|q!Q3Hk;SBtwM&DQLOjpZVZOpyiG?nn_LbRJw>)c`Z2 zJM4DT5SW>aA_)2zsB}*meJW)0X8DnCUx}1zjKD8U-oocQB+7r4B|M)X=-TfJyYG_8 z9Ogu5qy^tS&mrIf2+rPo4dc-Mli-q$XOSxqiCNyf-T3*l14T#z(yM;Xnh%kYM;0Wt zXQS9s=?k}g5}few`R_=(B%aaqKWg53!bMxI2kdo?L4JT++rc`8%ctGdp(~O;Pi4LY zjCi=9JTow1u%c#aN&yWtT)vdaLsjdb2$5;GT9qr;#;-@e;Qph53t`=00 zxaQ#k#v8Gc!cM}gWP64nwk|N@uB|QD#F;oXWSHxa$t(#aDO@a+HYQX1xAA} z#U)c$Dtekw>c$N``|-+Dz6@sQ(vd6z zZTQ>EFlf7I49U9-;f69*bKlGRieS3-9cnIdn^oKeY%5YPVYeLr|QJNS|fOf0d6nSx>hAka5p1!17?){@uSf^9k|M)v+9!snA_rWSKEvA-fVJ| zw^PiFkM=I-Oa|DoCpGz})pcUq*S{R?z9XX=P7iEjJ?##Tl1(a8`+^)jk`1k8gv@+*{cmLV+OWBSZf3DI- zhqx$a0X)&8LdQE30u5m$2R?c!#lC1rO*nB9;vMmefw;GfYOVDhW56ZUrvSZufWt*} z%zo+JCuBayw*5mHiRCEMh;Jm_SmWpq+LenowY&rQ(u(BU zbiWqB;oP%fdhU`aU7bI!v`~Yy!Q(tUy8NX}C)92AIP>NzrY+o+xk5GN?$bit)*|3bO z(S~oojD?{wPgjdt_|INwqWZ+Qz~nh7{zU&ZH(Zlz0tdk-AXSy?b$p3SI7YWaJQ0>s$xD>ApY>0?+N)HgFiGKB!K~khAScHpC-&1bI&Tea8_* zCDGEpQ2xYI7T@%Eeg&5FM<3vD>fZrNqjMh_(E$dv7sCcyhP7i7^h?pzP!hPj@Lkco z{QQB#^keOW0>liu>j7}8ejGwmn?I_i=L^i#+enWnu*@s?E5uPKDjE{hkSdg}1g5kr z?#mjy9)3UUkH==;n?Jq9wmWZh9IV%^+P@#Hj;?G(wweyO ziUze5t+;i$>lyD0=>;sfo`yY#Q`fG7VMpedy zQzK*u<&GSlmYhmPg7o3R71V)TnUPz=Q zkyrwz0_G_HDyyAA=n)0x4Y-tZKTJvs$=1ftL*jlc~4s|pj>k51mm7jo6t9IT zuN-IYnL*N1GslaAp5HB`H9Fb=*|o32J)i*>$S4xa$q8X$tz(Q>4bjj- ze$T_j6Y;7r5}xd{w7J=d<&NC-L(VFTirHUHP4e+~^+s^7-vFZfoeg}+*d*3oHU+Md zJrg>2a~`91$-l+q;(ohlrO-kMGx&#OY~XQ?ZA$< zn^1m$CmvG}W;UK^YgMl^k2%Z8%ORHisR5f{*+pb!(Zu!KCX(Ob1fH&oLPx^Dtb*x- zJZpJ8_miky0#>yzRuNqT8xl9(hF<%u>K;C;x)iY6ZOp07$*6=FSd=b&IZbJAtSDcL zS+De;zc++%5IOq4<`Jh-$(=HLK&1lF&_I>Ut1NYkL+2Qw<`_2wm#*H2f~=~^29sQ0 zAK3%SniyT9M)8K8Qynn-= zV3pZav0?M8*=|a@IRzXdX5|ftN4arbhj}GDx&r;P9@g|qE)uVTb8TGgwsH!HjWQJ3 zHkV(I*FA=~W+?8woXv#fVw~-_wWL?^h9G^Zdkes431OXDSH&*+J6c_jibZ|emE>R^ z&UavdeN60`?Q08$O-0Fq5qWPB=--RC^Z8~mt;|tTEcQE`Ec}|ZEP6Lf!Oh2Jl{J=3 zZ}PoMT(gs|!Y)~HR$oQe{Nv#eun+b;^|hMd2>YMws3<+LoTs(@Ce7_(uhTt;_K{eD zd4>|i(ts{5eohwFs%ZhLy3wOdnspH(m2tJpi2WecU&JX^0UEYKVQ_(KK^LKKCt9Gk zLgs8C{wFJZw@nSgF;!K5Q0b+Uy~`1fi%rz-mANwQrF>!T%tjJgVjJkDU>WwfeU*cj zUk5MpWxECRkuGRu!3_QFod@JK;*uob`SmuYI zwjwYNw$j!>A6I_2yEJ0AFty}y{zv0l`9C#I1ay5h2B2{Z(FhR$jZ@1V2K&^wNU*UI z>7MmZje}X%IigJZ)VMW(#!<$+V4q14MV#QmMr~mDH(81e(l{E9Xsh(*RFXgKiD(kJ zXq%?K+T~Etgs*N#14c4Kr?x;BZLNv#-{_D#=Q6@YO1xcL)lsJ3)~v9kIv~vGw z@*-1o@FXJO-43i^FL_Kk(QEqEJ){+WQMSc?C8qm2~# z2Nb(#-U`3_G5%^xc5B0skF9K079w-JTMDNI#;@^=f~MBW+mw3R3TAWqaQHg`b@%s< zF80?z;1e4a9Yyw-CJa2f$$cACqtL!S=$+f#>)RCVub2cINdw8f{+w<6#7(1;?$M@1Z^V(YRSud?@!kZp7;>*40WQ@LbIFe~f(lNW08 z!i6izZgJg|6nSi&u4&~6`xK+-&pHG3rs)MNdzzChjp;+hJ-hRDMSIk?oPf>*FUb7i zJdDkViWHjpwn6=_k0ld*h-oM7az4JCXy0W&vdxTK(ny>H&gXZ5}jJtjQtDQD~PO`UTt8 zgT;~FF8QE1XjKw1$kRtRR=FB57~y=n%4Z|}`gQa&W8j3_>9hFLgC8AN-uQb4Y-h(yvx6sl7tV=2xpa#CFODn+eLwbSqE$bCE5f za94<$I>SsxryWM{+AaHVFxoE+YoYLPbhZZ-Up&gE|vPOMu%lJw_|HhT&W)K6I@8`ugA$%(BJGY z+PoWr?Tka2M458MY$p$K-f{FL^>;h^!rE)vWG*3gDm{JJM$lx6-aa{&>sBB5h(o zfqPhM>*~FXB*v-&vasr_oiG6bE&EgjL^MYBuNo-*VFe)-WCxVt-frG z$USIekFMJiPNKk9EG%=rEI;n9d8-(~w=k@OQUqp;t3w|JA7>ch@h#58x5w92hir1E zVO#&^N+FO+SlpE;&0?9Xo7~(g6WuH4m)gb1gxHXfsKG-)%UQd^Q7AN8bb?( z93jnFv6zI+6u6BN#tNp8mf8_8FYe?>>ABKb&~WRPdm*i~5qjtAy+a^x!dtLvcMX9~ ziVxxsAQeCs#pc$?>iQNpRV=bH1gue+Xc)HB`Y`ollM2f193aPtG4X!!@e`HFd#@sFY;y)axR`B?j z<6eFSm7~%{eBoYcG_#7++fc~1_>eh{HF7C30918rV6m1Q>00YjSbG6xhUEpyX4@8i zn>8Gk-0MGDi2Q_cYN+ysmUc6AA1p_`?5*p(WG-&9Fqu?gy{8<^ zH4w@`>oy{8k?ZH1sHNYt=Xgu|;QD%)uESC#LHzZ^VkhUho@#8#!y^BIZ-4yr><{}->H?aC5Kdb z8N1PID8}$vGiwUnKW&5hs`hcCl>_F>T6iJG%8}vtdIf`JhbU5PRJiz<_o7#cYwx+w zEArZZvS;z#$O-$LHSPb>emf5(rF7^IJHVCzx#|sm=3C`_qtMv|(A-npwn%}~zclBM zQF0vY`AKsse`)R=Kyz$3(`elq37eGpwSC+*K!0h@5kPYoO#=U=xxfhk&DjqzVB6vU zFPe+{ADW|ovhwEnOLG~?-#iiW>>Q%SZoF?d#Jr|Kzc;mK`5jrXz2e7&56(W8{1tkWmd!fLvxKZ`d&4@Oh#o9 zX`FHa0GjK**ags>@c+=9^>(A!MnDiYfaZup8e1JH8AC9{UKwjYY3>qr(CY#B_lFBIwQCOMi*_@{)&q--;|p@AH(_1&mCiA~ zh)6k)zcL5Uarr58Nlr3SsiAJ-NV`#^=a(yG?_C$`KCv*Dp6 z(((L${|dq~|CUg~^RN}yLZrC`4KET{vVAWO3U}^BGH_?fkFj4vTu{{d+1o}<96LR( zKxIsm_`@4zeEos@AD9~fz#RFyb_f9GzyUCaxuE&~ggGa%|G*shYd)nY=dCEqX4c2u zT)3k?LEdS2NT||goA98e7P!{Sk(P?H15Eks-!3kUkekp2z zm-C96BvJeVjQAXh*u&{zz>4(XjVU1Yl~U@vu)xzMT&_+>Cl>_uSJfZTc?Rt0L5o$c z2BJ_7!_u(*yez*WKtK5B5ZpB)xx3Hrnl&XZ)Zfy?9eXn6Q24y-slQ3U^pr)|b_gn7l_Xfovrg46kx&1i}QEO;W zfXhYvpDy<`P6}sSPeg^uTADfiR^4v%OSJYrAM^YDyu(LW3-8{C8+N_S%5n@WW{U=f z3pFuG{jAbJeRM25rBbs6V~0+biHrxF@BVp;A;*!75IW@cL69g~C=;W~41tRg!- z7%gRpc}&c9zRvJF3mLoUlmPC7%(;Ak%N^lIC$rr~DjX(#IH)h zim~g1qWDC`jRbF||3FE3535ruT~?r_&2XUSFS<^e%upm&86EFxi3t~+%}%ncbH(7d z{w*nYFznuzamspXzYjqHtMPolI>yFr9{POA)-$sVhrfk0bfrt03bg{Rds$B>(*?l+ z5`AJAH5XtL}7=XYkPT`rpTrvM}F!C0O;(qVwbXLhym*~~08N^|Mk<(HT1)g&u z@@}Axo%3(QApTi)sZA)pSUa1exo-CW^y@SwQXQm`&onL~uv~5UGmT^VOykJlO3HjU zUUtlMJrU6?0Xvt%Qxa?cxrZSIuIV+`5fWv4;ioODmm zk8P_7ehVq~^UNVn+oj=mQ)T5k9PVd@*uJO98KNi%dXH`Ps{K(bhi{bM%n~+>$fu`% zSdvA1Z1)U>XCPU=jvQIlOL5qpFj{2ST*E*@WkXsV83(!Tn`StjQDOKo&!!tNiW^0p z#~QqLkMEwuH=Uaz(g|QWgEKsmK;c!Fs(X7Wh@w_|+fwdGP4eEV*`fn2y(aO*=rAE| zQNpM@0s0mdSfyAr@B#w|yjOld0Lzt>Ox*)m4n*DPFUwH}F_4Fo465TMlxy(gU1Q8m z@jhd8Nii=TflMyzP^TCN**cw7hBPMq5kE2MlQEh&eigqe0j_4#q~!cYt%Myj zTQdMd@vG?v{aa&!41_O+3%Z>Rn!@ImOTO_$P73Y*(xba6W zUZ)mVnyBNCz?>Hr`GH2YO)}FQuT~j?>IRcx&r#i9uko$%$M0FATa2zwpoYJHr<7jo z?8zKkn*^X=wkh`@$v#eDsR2IR*s{W1VC+SG+Aw;IuZQWSLIjh#lQ3`xEZSnc0?{-_+xE?M9Fv_oA*FE{YM> zbP$I_lgFvuf(oDi;?pPghxti|3lndlsT-@Dl5PylFt%+aN8(?W`wn2avrC%P|FB%F zY_P+C8i}brhotztMSwJFhS5h341ncKP?@_Y+Cw-H0W3%VGW;*gO#+o~cZUL4?wt<< zz;dWV89&f}yBPdb5D=hBIEryfUf70oZoyNZALVFoyxOKg<{ygek6t?g8~{`-C?}Aq zi=Ob>^EX{1>Uliqf6>V=d42r}$m8U^=^Ma~V*z>Ge^@S8ohJG(%eDT?atOE4oz{N* zvC{%K$2G*w;glCa2I-~YcqpxSi7*laN$U|LFReNm?SqpJd`vgr`^R(%V=!Kdfr27L zEtZ*%b4mZhauxbDjEml847

    9mx@*B+nF^n4&9RPgGZsDUZd7DUfAw;b)+xuj7VT z8mFTh94Je1gP<{V#5)AA961w1{CiY{9V9>h1jG5`VYo{>PZAj*k2}ioI?}^Ie7@_Df!%r* zPi$}daKVw_o$?pu=HBdnDEt4j92hWE!X}F~;E3w-)_3|tpHcd9D^X4dNvJnv^))4y z6sN8ey4s(W%VKk{UtqN#W=!>c9bkG|<9)&_(jyrb!wuZv_WQ$8O&19p@s1y;q4-BM zf@NDd2pjs2cU5E=K?1Y!ij?Je99_P_@1vd~uBPI-N7`-kz1PR0Q@q8~=P5aTz?Fxq zP8?aV+gW`>t{(h>m2wb|gT+3*7tqT3Y_edxw-N~!FzM>#0eM^#<>o(m9ME7$AlW~892a~C%g#1f za){giC65Cf0Q?>Y{cW`CzXt%5DSOAn=?&-+_9ef?5QT8~`H8esSBPt>C6WKDa`UYU zvuXtjLS>4tNVjE*A8IGw7w*>Ul;8C}<}dWG*ECogm+5|=OP5H0+H}_C{OP2$d zU#=z|)w-?%ju!7$1nG!!@R)ne&T7uJa#ldfmXqX$AV80+vA z0;3obM=IL-a#7m5f@CtRSW=^qBp0wSx7RiqhB#w{qqiB`MBB-XCA3k^X|Q=><*IK| z-RpKApgFLCW{J|Wu&%)*pdmT>FEF5@?je4qSd-Fbh+<%vv60>fmjv{2>y!3ra}5M< zfIe;?bN8PD2S=MqTOtS-M1xHO}Zrk9&u>{j+~9r|@WM2!>4&DXoFrr`zRg`GkINFl%$m zGdo5(97nwCe2*hUn5W?{je@vktz?**xb%1F61L$#OP7Jmq{cV4T2X_+;2kN=2Q`P} zqIGx}^)j}ugluy1X7{X*p+;VP+0ma%mo6NDrAvAA%uKYb#&Gf=DLPiZZA_lg`%US} z$^HyBo>7M@X6uk*gD*-1?t?Snnac4zwqe;2`8 z+dVBW-e9+|{|*)?jgv|F6ZbL#IOz23qkpxuIJCN|C z>pa!cpK}c`bcqD$;|%}P$2kK(9pcj}jH<<(PH7_F_zV1&6>8@jfk$(NYiXx^72)HL zd{yfX&-}Hrxi3QKi8%sF^;-pj;LmD&l8>jWHws4stPiU86oiYPI`O*JAu#2XX@97x zvlxL(* zIJXw14%oTW@BsbnfCgwdsJWZUQ7?D)%&Qx{Y$ftW>y~_yW|K&zxhfJK z-QHgGONEY8xwzNIA}&{P9lKYv$Bi!z$jO^q_xEn4iHsj)cn;8ZJ*C{f5jsA|3QGKU z=Mu@^SVSci%XS*4`=Fua#bsjM`UWE1_hLsZzt`uXzR*}+m5Tb0eL=zP7|KN~8QVE->u;uI}8j*{N0n zm!d4GmRwnXhB?E)M3HrbAm70$bj`_+w63ca6NSqum3|J1c)q3VbZ%d}O$WB(Kroo* zfElvt>VdOWG}eo0lP~dh?15L$v&&*BcY%PJyOpTzwwml-Rb29bTevSPqkBo(_0ofF;?uiHb!V=+hx@_pOiuBE z)HGf5ZS*xS(lw7ekp`R+Z==>64tSe5&WD$q9DfM^d?jnXIxlzGcQbr1ov%^=ad2{_ z-hOsyFR!Jgt<6ogFbzPgHDK=BNjf>m^VUN5>OtB3l`6P;+oAC1t|OiFsy1SVx7{7# z%euK|1OVhpZm_$S&!_(dISK|hd=do`yr+vZMwGuGmnMMc_~TqdW=+kYi?wJ{8bV#H zLjs!_c3@xXYsEQ*CqA`A*$6shui)EM;eJf@S*h<`uQQ%v1hj@yT&zc*4e2+W90=w95*`Hbx`I7w46# zUdBOT2e!nWW_{GVSC-u04{)0_&t4%VTz?)7It_(MA(`zjsz-@ha7NE%lEOhJ*iY?_ z?fu|%sWGaYt+KD|Ua#6Q7I>kEEkq-0Q|PQm&r&zPvf*ynk|Il6i~itQl0yVlOy)G{ z_wC-%Yk8UUNzEC&Y!Yy{>7O^xPK6K@>$}XWxY(70QD27Y_gmsPb>dj_Tq9syb{7WW z+WpB$}mxV^c*Ag7sTv4^sdV13H?7vyTp03de`068H5$gMSeg52m|kUI$! z>{{`xng)QJdoc84mkog2Y3HscVVSn`2pHt^BkG^pPe_x1!SrPo_g3s{bYIYi>CZRb zVZOQOIFMzcdLmY}JVHC1KejQ-cQQa$tv*3jE-_(wke)u%aqEkX6+S{K3Qy?eB;q}J zoAUNo=%Q8IT}Gb0qfefv1Pv!aA%jHS3I5Pq%e0_eXF!S4ss++M6z_^~XG?EV4l{nH zk6B6cN4cOfZoJ9sh%5nk9P8TVt@!w&;}Pm_*CQ{?=2I3G$Cem$jg7sG$JxCoIY1tF ziDYjy;v`qF8?$k&SRv!10BB<(cY#iK~}cej1ts(!utg8Yo$DLpp4>ho10I>zp(M1h1+$_J@PrfxdE3SmP~ z9vAO=12-0+%LLp)Z1xmw-i*d}KBY+b1UVN=i1XHaaz@P#Ol8f7=_XzH2OLHK$c59S z>J^fIVfAvvn};FM9j?s1cWUBNm;qx+2$V(c)c7-mhN^j}1Uhs#-J>G)zd#Nv4e_Qa z-uPhV8?b}i7c;fjdzlvbJUvoivplklK#D3DmjlkorU&n57g>NxAAn0 z-vi~n8O<*V`8BQMeuF|>@MRi%xdEa2$aO+&FYzGL7pEr&ruU^bR`x4L7|^a_zIr(K zVnnnQYK$GdRvcyNVW#=%AsTzKssg2II^@e%!?@1@VSD~;C0CFeYH8-CiXB?BKonM*Z+M?Rza z;T6Zvnac@vtC>qSDv_h>@&~}oWe8z%{oq8KqpuiX=CV}?=#G94jBrC_2^O&;7ByMW z6Hk($#pXLULr^?hC%bi)&ivtGSqe;~ES8I(Xq+$$o9cgOE>mUWRnfCeYyO$JG_3MP zC|4^L9&998D*GjWkD|MyZ*lWKeO&2hA149m<6@=%?c-)A%QDr6|5qP(KD3Xu=Tena zh`$5ust?3C%GJJkKUcS!+7sMNJ6XMgC$5DI_|>FRKKnSQ(oCroq5-f$y_a1~yD(r8 zPNLIrd!y49qB`HLtEG0&+C{=F6kc?T0T8F+XQm~6uc3d!}$LOx%FZ{kJntfzaXdh zXSaKrnMvr{!J*Sv>GH81laq@8rp{VxkX-}RWpDh5&8^K}UsV!U9Xei&(%)rwpX7?p z9&@P~lr)Bokvd|d7DhfwI8HeYH)&NHIEW5G*>JY{ci}dwNw$Ryb_oT&$Za!OZ>(-$ zYs|N3A7Qr)>P)6o%QVe6c8_^QX0rj}8=`{>F#;g6PDV?^&2acU7cVj2JF`(0{#y1B zp}=o4y4>XD1Gdu!HDU8U1W5B(du`>6=9CoQsVo^)))QCIzS9WUD+vgtOdrc{5s(Eb z%)Xiwt@;|9Hch)0?O|yt=k=F1{Cb=R-q8o7a!_t@pQ&6M3kdO#7nSNFn{EK2C9Bfl zehvObokvz>(4+eXvJ@|1mNvBh64I1apMsBtx##OtG*NLJ-A6lIb#{@eBe z?1N9U*Q=|}u>PNb7n1%cv7N7EUa+-sUr|`(7GT@@PhIY6A!e+G2UVL4;>J{?C*bx= zzmf2Lj#M`IG`*d=m2xOP&dk z+LH?%Gd4xfx_;9yy1^6QMRYubHt#nCx})KxVVCP+ht-GMp4-iiG!Ji*(}ASS*}~Mh zE1|K6xmvyo_T~u!p)DaGPx6_HSLXG7h)Srm2_}Z6EaTcKOs~#9OSyxqnZ6kSg<0A- z>+SN5#}gkCrClwQt7_f%a*(1VG>ao8>f!b3N6krtr_apF4DFrtlHT#~!WY>09Jn2+ zg4lxvUif3_z3o_e@S)yu1wvg6h;iO#?h;73qgqYQ5zq_%j#3$7wla-Q$-^iKMUwAy zW|Ixp-GYRzm(g@+Xo9IO=jIHc`|WLNw_cU3B38tsg1A9K ziG!}7*$0<90PKx+r1{6gDTT;r+o!#iX)wmw0_<(xnI&|xGY#f(-rbTg!9SUdad3bg zU~kV0Xg(_&JOUr%{b}5bVNb@9KPo|uehuRY3+XP4kQ7b{3V6Kak@;AAm7*X_?tj64 zRwt`ucNQw=HEs3W4m*g=>to@0BMS+BzYi=>J=)1yo*D!={pLZScyQ7vChfjp{}t_;tw1uZ;PQ z&_n6vXNm1y5=CbW7Um}!xH7dp$0j0)7mAs^Q`KnRHoeCd^N zL&pnKP{ob#SOuA}^Gnkiw)2@GC);}sm?YWz(!m&vNf}`Jc*skB{zM*x37nh-4@Gee zjVah|<}Hqx4qQu!9yH{_cw3icYQP6oKPnA7$P4}{Vj6QDt{Rb6|A^SSmUzi?@mIiB zq~h+Cib_Qqt3W?oP_RiMe_E$GIVG5#I;KaTgp3vTnHy0GCnkWzHu`~c@F;je$37;+`0tj(oNxDhVmVxLDB$Jn_BL_N!_LNn^u5GkG(dM-IEMz3 ztbaaqWO?J}(Qnie1qAUkq#&b55gDh33Ny3qb z~}RV|W>~03vpR)D3&hxLZI>s#EcMRlzZHfPem8 zKQNM~##npCjCh7H zW}|}Np7dhO3{ofvfP@+ox)nPl?osjOP-I{|9B86R>^)ItCn<~Kzs0n8l|j|X;gS9m z)hK>NHTK7MDKv-wE2_0Z{EBLtbA4G8E1Ip%)W1ZmqqsVObHZP?u`nhF*(l7Jb9WzoaPY{Y)gP_c@=~l{N(UUh!O@{KJlD8Ql zoX_O3PPtaiXI=+r?a~qUC?f=7Sq-I~IJ?XRMGI&r#-#EfZu5<(3;a3O^&Bs2a{*{T zYF(|9IOo#={^)K0Ef&vPO|+6}gCwUaMDQ@&q&02n9neaiq^$thM2sTepEd$%Q4qns z2l!jK;)}{_ub>sG33h=(TSY~3eN$i}9@%owGNh!hrw5rP1Pm+0xt5yt608(JpzLyl zK;UoG4apm&C&oq51z5sjeG#DkHVM^O792*m=l_rxa?)8IO6v0Ie@IO9e@HBD|K=Bo zEx*NX9X-!_m20j2XR2xEkF$2RKLp)D{)fcqwb|zBaPevJKvidf!cY|K{U@Xqw57Hx zoce9mL9-4goaMw6ILz<3v|t;?_F=?^0~rl}Z?OL>f=swu9Jw=c<*bZ{y&rQa)dTHG zbq^+TkY*kHI7`PBn=|9l%$9k?+=UX~0IOJA6``__C6PRyB_b&H*VyiJX}{c-X4<6M z1bWe1XcBKV(Ivw!n6oS@SecMJ}FhT(Uz z7SXc|%-DN_7W9$dZ=m(~Xg$r(*ipV01V4c#a|`~M(*48%^8Y-v+z$P;y$q1lZp&Zb zr2+oigM9jt8Rb}eF{;01h@F&5l|onpMffiV2`45-MuZQQmSQw&L^7EHM<5A@94FjI zs57)&^vk@G{!b24#ZsHXqDrGYU`gZiHwRhqZMpQ*_0pB*j!5wQ)8vJl@N(^N-FA}c zIenA)@%_wqxxgxft5umnPSpSlnWC&T$e5y?qZ7iDMH zDPjWjgY};dIAwnLUE8T)E90?S<23O*ka%^BHsHOs{gPk7U4q?~E#l$fYy0Wr^Yhcy z#yWIDxFpqs)baDYvtvaacau&xX%qS16C)%;pAf(k6C$fhxW5;)PVPkVwa#nWH2n2< ztjnE+9rk=q8I$cavc9}W-C|^ps>%??kIsJecq-1&5PlNg>&W{g4VwvV&{mPt5FM&cA3;@`Eiy~!nKmUe=C15DaK!uw+FQ#2MJsF6 zY-csU8`U(l#DO`9B?ou;twF)~7$lb)nI(p@CRuzxc{byRTHAS@4Zex70uI1D3A+D! z)YJ9V&0IUUd7!b&k7?|CPaa#X&n*T5wn*K$ad2@SO?Ib82q|0dnV?kU<2+kiON*#p z*n}<|>_-b}j9;GO=TJt6145LzxQS_;@sqf(3=W989Y2{S0(sl$L0gP}sD_BwyUJ4& zW#~?ts27_#GPQZSiHAe-L5KOeP8CIOr)^?X?I2`YW=UZrNqDHF;5v(@*8F=WW(a>2 z0qs*fhkRyCllTBx^*a1a5cT#x^xS%^ehAcHYk%%h#H`0 zd+x}NEAdZgKoyJfk%M`T3dJsQZ=oypA*#kxk1o zE-9A}oC41`xfjpj3bwQT#Y|zH{FXX~PFPs*N;Zb(T+K-;`*oXK?^sc=Da9M9(*MI-D(tQN z_w3$*Jaa}ZWm719t2P$4B{0>UTU={mx^KRWJUZ#2w#hyr!O-N1oj9_WQ;CXH3xtOp z7t($uF`({JxZ_VR1{5%Xz#D96SX$pLnt=_889r>4M?)^GlU4(+X z^rjcV-h`BSM~@y{0I`z-dvbnSJ8Mih^)~wv?;ju|{_tuv{;jY)5nk%x!jy6|zA}0; z_f}-@mjCDznE#(SZ%1X}Cq#1Hti!!JDO zJ8M&`t4H8WF&Qd_7^19rYPB|gA8k3)98slX>tJ@_HcA1qXMDQF!O#&34YrY^Co7T7 z=d^3bS`+{T&0KJjph5uOXa=6_xOet#TyFcxh6-8u8>VaC-xn~XC2B&!ma zCdTJ3x+7(5!m%uqe|n!TR_M$lhs~*`BptE913Xy~jYnqrH`pM(l*-Kwzp{lbDZ@G! zQhtoEUC=qyGF;H&9?$S>=Lk`z4$}%dOe%eGE638jhs5(XxjXUMVIG=5&*)8g+UE-9BZvy?A~3 ztFYq=QrHb+c~#8cA-Vs|KfTE3QM|P$S4rGjD116FmqskUSG7ogw159?hQz6ezS7#V zfTehHN8=<{l5|;M+S9xfo5shd!o|!R+Y`6TM~cyK@M*D$Vf;rk)ueu_qMWAiZ_X)*s8InL#@pOgbg~Zl{+dC7hUHc zSs31sk7_r_EX|)jPm31g{icoVA><8Gf7qfc-rsl%xO!rCSwEGMvi!s@Od>0gc}b*e zwTd}rpnr;CJ~dLjB#B^aFy?SCAvqXgR`kzPu&~O%{602dqpm0hha6Or0m9{WCtH&6Z|= z4D^QN&(m1z*E_da+wZ@|uDv5k`S@SF)o{=Rpj$6AR0?SK*#5T?M{00v1M+AZ^9H0c zPlw{8xQ6b*4)ofM*}l*u@X%f!wpW1^Sa?BNYk07xm-yPoBa6F>AXsw~fE}o#Bcgjw zEuY}LnxA&24{dze8MeJc?Oa7@U}k7AkX|B7kOBiAO_fURu21pq z?i?=Jc(+*fsrBL3IKcLZ~!b%z^!*Ok)l^qXS9C2aEVbG#xfwa8CWF8AWMLA5Oq#{Kb z>u;fe&$L2%$Pdv8I^LS)_)xHl#?(aL_+68xc93}* zkPQAaYY9TVZ*an3nAA#X&FVhNU+H^2^ngG+LTEA|CLbM@9j)X;EG&`TkbOA&rer?#VpO7S<%3jeOgtOh z3UF(GtqHLofD*{M89#!JHf=LKoqIszpx~z36|AKOcBg_k)gHJB>JCdTSHam3-Kh-V z{_5`SK;)<*RGNENRnAV5=1DegnybRb!H6k~I%2R~RiQRUgj>_aOueys1gAC&o!i29 z-W#x4(83cOvtcl{9>s^6CUP)*8mFA0EEy;Hv(hf;;)_lFc69aO=O89BTV*!#b~ykc=YUznUnVH412q((0YErp{Qgl%x?z#I}cf67Ets$|tkuKN8g_&`|Oi%gp1 z%?5BdgQE_6e?Eum2TlLE=J+=@&B~SQW~-C)mGDDyUxD(k=PtpB>%%Pn z^Q}NuXq@*ai8J7s?no9%|LacRlElJXAI+ip(khoJi7|gxa1U((OzpZUsTD{34)LvvqNK z-RFOuG68Pa_}gqYAl8CIt6`5$*9_9VeuH_L&}*@1>Vhm@~yeS9a$ zBWMYONKj;tD+SwBs$n;1>kwR)mR8w}14jKQ;;DSb0kT$KHPoSuR-kRJBm!SI3!2|| zhWNg?W%&=!&+`}CtBj`z8gsa}n%Zzt32DK}BR23lPq^_Kz9Ef~o?k#Dg#%Mcar2g~ zk->ACK_!P_8sCY*PTHoBKc{1${}=0lpsC3Sh{@iE>9rm!39`f^tT0d?Q%HC4`-cm3 zQlRhIV2NY=6W2S4gOte7IGf>j#8C{ohH6c7hW*JlL!}2Tr;MqY0)r@n2Jl(ySy$6N z*cx0QAl=%@-6wW z#kk6lj#Wwou+%dlhMCUqws<-gsFmN8Rt7~9V>1->buxuFk`>F91l(G&T`E>g{NekF z^edX2I_h1B-Kmj_6JD80@vqElMFsz5?;j2CUa$?KRO=8)X{gHR9~1qIJH7rfP@4Wi zPy27Q44WabcJs1;U5U5i$7&+r;Je&v74Yy)YqVe0M&h9-4p3?M=2(EcDM#8JFLvU| z|AfFnO7==$4tDHL!s4=Ck!i9W%D#WO*?EIgq6Kq|(WCU%w>s3A&*EVZ<45wX*5hwm zGbY38RAlrbgk9zZOBvwf;epD(!7NmRFU9cPHK3zr`p2f>kiKgh46|{w>TN=0We6|O z=2=x_i4e&I{R1tQd=24oRK(Y6TAoE@5ei`F#aeUT9k9mlmgI7z05Q_WX))*AyPhVg zvRnZ1ye~7JvRN9Yd)!JU;aR+PJ7n^xoi^eY?;!Ycxc=D zjdP=-Z%GY>V7N)vfnrOC#UDQxve5a-6(W^NtehL!#sC~KPpl{Mq@!C=Un^j$2t2^1 z#hST+cww0p0V;Ph5H&hu@4s)i46kOH)8mnRM71G2!?STIn0Ps+M~6jcdUin0Rfqbh zrrsEivxOEZQeSSPN}g-VNNsSE+Sk)-i?Sps3%K2NC6;)MI)a%ZrBVtyVBpT{<26jX z4)0PF%#afR0|k0+#3K4~Wz+lP$CrzG%4~ExxACY6CUJ3Rc5Ot{1fOsQ@$frXEh*OKjFLBv*|3SFI*an<(NalL4%O{z+I>p-A<5EYMmv z>UrsvH6b+h`4Kd?`Pc@dLYPo>H-8|)ECCA>Os)0gbrw$enzr%ii6jGKw$2Pxi{c~l zd}zLhv}^s`Eb#_xa{v?YZ^iwhFS8(v-1L;O>J+@jbET+!JG$WKoi0DnV9Y4&WWC|D zzbm3YeP}94mIW}_T&jyPEh_>{*$RBdOVQD2Jsf7ZQmeR%CiB|ASGd^3buwjHdAp*^ zFDKmT)^xQ2k9J*Y{g~ljN2@%3IwE#u@Kl%j@ZNSfUPG9i1_18uNwd0K>AlWz)&B

    %ypC?n`%B*Vm^(WE+zkxy&W(|wppE0lrxzL7cqQ74oCNPX_0tAR8K`Au~F%O>(X;Le}75a0Y~QPYXEP@>2*R)+*tfATB@Za zF4Ewdo(fpD4?=`u2k~iKE8)0Urx-V(WL?j~hA&DO8=t`U?B2(Ea}~l&I0$Bk0ow;b|(ve5tvRSG1$Fc?W$82napGh4gx~V0d(jiu!$~d(lVHci;Xxu(>B-)f+FE| zQPkc@6p~7rYb%3V&p5m8U)z*WeGTINr_;2}C{##5Zv5h>qfh~gMHtGFrItlfCx`W( zGT%B}aV}m^N1?|z^p%nv{cNYlzJP8k7}MN1B}eCTUjEH8!5R}}y~Y-f$LPf35nvco z531tz8Pq{$;>|J(Nz-u}O_ezcLQ>!1u7QUE`F;$vmTKHMK{%G0-b0QWw0o}-Qv^9< z6xvF!dVD)da$R$i+G@Pev24K!WqCBmcp$Y>*h`aqEMp1u^-#zKqWw@N(7iHdmUO5s zK5WatjbmV|x7L#bJWx$?_rjL>yx&iNgL&zo2w5t9x5tQL$#H401;lFcKFMHk$j57aCkB zq%0Rnyi1H|RLEKWQllk}CMDns>pRie8kPTzi2Xlmq|qHS=IP4*V)asaQv)mP?SkiE z)n-#&JI+F-C9lJCbGsgW`}!zjgnC!Tkgyz+@%iJ0=uf^Qjllo zK2VMkC|(N|!Z2~3K5Tr!mERgp&9v)Qi8Da>ad$n6ej46MP`tf|pbGnJi^7eNEQ+-E z5I17)bRH&_rT7RDuZ7wKaOjy|@n^)a_@G#KXdIlrDURIQI?I}K<8dJ(d@3TcxH(=L zvZ9u{Os1Q*j2;TL5Jlgn92>QG*oGYS^Muy9omjrsWi3;NzyAK$kjn4S=W{}rZl`he zu00F*?o;ti%X{^X0)O=^xvza#2=sg`c%qBHozuD} zmX|0YzP#4tYEBWF+24UnHcV2Sn)z!wDt2fZ+1@R+bmj;X!Lagzr74q@nZsFtTjz*g z3a@}D0~>~q;k9-2N20MAojpP)_MBHUqbr2OV}(pxjQP@>ogiV}Dd$8p76kitM~unc z^6@xa%;7@dKbntDR};iZXMIaECrI(X^-nhK9FE zV%>6V(o}e?*Xlh$;IwQ+7-lPBc{6loLdpi}5gWH?aQ?~6Ca*tG@nvl{1n(d({GqJ%tsR1$!CO`(} z87k!a)aCqY?wYhr>o>H7La;k=`OHY=du}Y>4%DM{Dq(lgpK8mt*f8 zo7rDES>A!667T3n&Ac4JvEzgCgY^<+V;8EO>67*zvph zVDqGL716ub$1^(RL{^SYdW1S=ql2)fMe$EIVi^MJ5){jPDh!5IDjm`s^SdFPPEqS` z#`~wsdo?jAak8d;S_Wy-zR|*b945Z-l0K_axJq3ES_w3n_~b2UJ%6-YL=!y#F<1)Z z4*@lv((w*@!~N_qB@Akt3jfBK9?hPJc{LIZjXT9l1fKycjQ35&uk2wzhKpn8yMSRI6^Tub zsqv6Pj7-doxhj1^9u_cW4BQs1F__F`(DpE!;*YL9Y~tPI;G&S=YS1xC@u;uCI;`b) z@u?c`+oJH2MKtdhIf{EF(K5^RxIUlW=Y<|WcEb|H!JjM z+Mv`3#<%z?T`FW9-B_YjqY`*JH-3~&n>{Lanb@NBz;Z|i@JguxYIf01iiu6MDyXY)F-(J|CTD+|0|+UQTB0b4;jdM8QC= zs=J^L$kt-A&(v~a^v*(TXvlfbC_0FzI*56=5B$)2bIO?EnVMAeQ&V%E+$SVGMf8}#9a2EeU< z^Ge#|(Z>1>XyrLwp$y$YxI0-Z4>8YTuc3l_de_d6$c?+@N6$&@d-ojvQ z!V0WIGls&vl}krHwLjsM0B-aQbu=t?Q3yGt>WgUpYTRJ$@E3M*S(D9-0w=QuxQ@pQ z=Qu%<>u33aVmHzHbNOfT?-tmWHmiQTHzCK>gxx03Kae}hwOMbpTTzLm!NF;-uV8w>>IsUWVz7oy17d=W`!Ka z%j1^sy@T(?A^q~Az7=6X8K==AF+F~S81bb7*~@PP+DMs!*NP9vKtGx!e3h7D!@g52 zE}th5uQE~))@yjX>uf8om4xvAY^Y8PS#rhgo2xom<)VM2S;lfmO4-W;ELJ5iAz_j{P*ej(_xq!l6rb^t&#Q^!o7_k31Ju2ai2 zoYgEVxqEspY?|S|T#fGK0YbsN%`pR_FQR*={%$BOdim^tz8<@8;cyY7W(%X{0-qIX zLZ9a$PJIH*nydP`=*K8614l8V&?dxZo5sD04Ged)eJjRya!`Y0I&`^;Zs&4^=Y%mk zi&1Tc$w9kGc^ey0ZjfP;WM&o2u)57M9URZ zseY+Uez{t70HB*>68WJSLbD{A{@tnmM6c!x@Jz@qZ%as^yqNT#ih1wRDCMaNh=IHC**f#{lpG@U4 zjfUB4G{WQv%y8@#mmKXo*SM>nAH`I%vb!{pSvu5ziP71@87c2H#ec-8U<3b`7!gNu zuw(oZqig;W?V(>{)X}(JvcTBb3X=|uTm$YgVfSn~0HzxH1B=)S)tS8qXT6&kDxy)f zxG&Fk#SztOd8{%?j`*n5L584HY!)`TBv;hv9s)dfkVoUyNoyJ8uXc<=oYE4)j@z!r zp0~k$T2G0kf>u_NqRT##6TmR}w?z`)KaZMDmyKPxKR-;>sXSgpv+lv{906p+^5Kz; zYJYeEmMQg%@$#>VlKkW@4%c!DcS1$MhUNr$?jw)`YA{K$0Mx%^qR!Ne>IFaj^Y;Fu z+iDbUmk`pF1YL5~Qe;Z;ut+T@XjM67cJt=LChKOf3#G0iDWeyEffEBbY^{z{SY_Ml z7MD=b%lu($wp?MW!eCf%7I6nxb}OAZ9{DYF=#)}UQ88ur3<7b81r#no)a~RhGPeQr zi6pb+HPoaE?L=7}LRKja<^uMV@v5Qg$V17c7!ZrIx<|a~KVDfE&7G%y!@JTgM|OZA z4;c&!XYG=aNZX30B&aC@kwan)*MFV?HUs}Ij!zd7+9nCY_^717O-CZbkC*vYSf!`; zQX>s5=u%?kWcZtg=hJ;XJ69UTN385*XX>BULr$K(7qI%C_hxP$wD1PXY7~qPQ}e;5 z34aa0&N-*Lab#UnG z;*@&`l{Ke?YtvkBQK1~>_(g3ax#Pg#)3`<6lo`3arJ(;4VvN#)uzjmGc@KzyR`&R= zbVEa(mo-)Q!|khBDO%&S83Vi7Ne_EPS7Ma~4VILvD9M;>o1u|=l?ko1g}Ty^GF>bb zr9~-t0x61qC|bK#Bz`UvLlg`cGN#Q~e9zbDKHa3F$ixXw6!6=^2nW9o?>9lMAJtEM zx4*^7YpW2%cIYFUFLQQ^PpzO#3=9)G-I*DTjy+RWp$@)I{6Uth8(-aaC(j4y4)vkw6rAJ32)Ntz9ot*ONDf4b?$@j4$2@_k;dllpY4a2;DFCpN#holY1x9!6=}0ieU@KF88P$ z#DMjnJP*=WWIDJdrf{kD&Zqol8-YY8f>A#j21V&4Im@~eN|Fp(`M;JXYHA_VDsvl6 zQ|(dpWezR5J4U~23dxGAh% z-MDrhjtC^*_}VgF56-=HJ4gD9XF~V;82n2!W^&&{+;X9pOk7)q|n z_3>8$?t$3o`#8Y6Sjt#~P!VkkSv+CZG#5*za?l${0!*@F-h8>(DkF9UGXZV0WfFPW zy5MGSmm%CQG%^3^x_$6td6iHz17So_rcMkbnL^BYA6Ii-VMQUP{cX5lr{lwRBW6z) zUKqY+ou@mnf>+6Amd*35yRlNq?1e7UnfcDRjca%)`0Tj-YH+Qy5o+644_sEElku}H zZf=wYG`^I@ezh_YV0p3n{*2(w4Ntl;7P@$hl28#Dro;zs z>28ttx$83Ob=|fl2>UA}mB){#(y?$f%!>+O^E1Kz?hCX1yuzL8cnt)Pu?xZe9au{z z#o=oK@sxPK_MrG@=X(`zL}&C5*Jq1?mb<-eq0o$z`%wz*aOjw=@26la?9Uac;@BPt z24$o7T`bpAj-a0|%Fq~Sj}^e@LQi*Ay+f_9Us4Wvcl;_BozcVU-Fl5n-#DS7o_I5l zQUADrS>FW;2uPRPYeizcUSM1aivK;!1@rmi23CBa$98W0-q=IgAtXTl0`@%7NqV%K zJ~Q_#s@zU#lTfD`TKzqOZ83>GO9gKixH|o!WShgGh1kg%N)3IIO0CJC9hKgtcoAR*bfTHJEev&NbSdno`{4g&y*ae0Fv0AbjS#$Q7G#&&;F>*du z=z#YJJq(_?lz#=fLa~T{9uNXpRL;ct&?@hlgZhN=A_nyRB0~jfKhi{wMfn=;AJu>w zV@Jhqr@&L`S{AnPo!vKON;*0^>e+75)ZnnnsYqpo`zgMP7!#rK?f%(NFuk!z2Mhl$ zVg)=%0VmB*RjVHSN{X>ZAI?m07Bhx=fN8~n68G*DDPL$9CdLI!oPft_Vm8nhARH zjq04q>iLNft-Kg6W!}U;5c=)EazVYNM~xEsR4HB!ai0}J0@P9=HTtvppSgXbi(1AQNR zoRxxmtIvWQMan+|f2s^6f_6cH(`lKQbkWUVG2UQh())@Url%CY<>1K!cf{f+So;4Y zLEG-6HbGS0A z4NI{o1pqSGk{IL@p{p9!^hy|Z9GxP_>1jp6dDE1?2b_4NNL2RLiXsZRa_71=i(?KZG%&!*VB_vv&w$H}lC5F^#Y%HAN z%)WQgYhz^zND6IyjPyUzYWGT{g9#B0c~ONT{P^gpfHRJU9+e3anbD&0&27I53^Rv5 zG^ylqUj~4$So9JYNEcVE$hlH9X@n<~YdBMMQzrA?rYfYes zq>@2krR5(jppsF^2=coI%d*jKHK5?`atkuR97}L3uz?Yqndhz!sA~`hX=h8Z0$k_Wt&fxe((X9qSXhWW+3FzSamDAP*l7=W3&7$2aX1Cgk~9g^@1)x+I}r|? ziA>S>3;o1SP3W=1Zx1x1&EWuQ_QMiL@+sA+K(y@!QtL(Dcv+P`{d!mC&FO$+o@Vl- z&8zeyyt6mVA-##VMA zFrZKl$N6eBsFQ222lI!O#Yv8ROj#_bBb0_AgQT4$wQu6cBW(T-^<-z70s2!mmH|ki z{qR$%<3isxr8KGGlT7J$7eX?B;ra+V9~vp@Qv zMQGsRjF6tJ_W1ae$;chjc&i}2(!y{t0 z#+v&VY>}`2#+PJ4OuL%yt{({#1V#qeudTxM6XG;Zj%mihWnIRa2#jHS1b>CIA=k$$ z8E2IRdPYsd+I3iTe)s*E(h{Dyoa7UqaX&Rb{F;n)a6~+%m0zD4NnOI4Eb=M;4Fgj~ zmKz7?Xw{u?fe)Jc@0ebn1aSa_O*EdRpMs?s{vqRFY+wD+M|e>|kbPMy_?3?m+5x4p z|4Yr+5UW}pPO{sosN?MZ>Tr(bRaynlCP%3=6WHHof;F8}8skb7@^^dzF3F?i} z{^H{$Qdqj%-@cv{m5i886`gsSm5f_8QxZc5g0(f7udN}N(Fb&vJ}a;;_&Y9(TkH!z zeJ~FZ8;h^FJ~KQrxvYZ+Cazgv$(6&IjJyoss^3AJgV8SSTd1?TfyqP`)D!Tbur*J~ zjEX7Y;j3Glp!_q{7KJn(vVK?Z$5k;rY3^EvzL`}Pep)nZ5{7NS1%h{JCLqFQopV{* zN4|cgj>6ggU{5(FA@ zlg%ASNdgpbkBschi(vK3I$haf_C(Q+Y$ncJf^Z&}v*3M$Uvl&0-3#y`wuUl3)}*;h za2+PrhhE}jq=?%&s^g_BL-seP3l|3pGOVY+#MbdqQ{7%8HiW_yJYF@w=do&ITX*a_ z@wD#z8}?~RjrP0-IIURof4+~J(#q2h%-{an8#*c;5jzt*G`=BYBqU_HzyLB0W4Pfo z(8$Sv2NR)9zJ=65VtLv4j8zuNhR2*j>B1V9`9+d-C-DZRX7lvo@~ZC5|efbEu{zhy~rIgQM`~$ZK=Ihx&$f0uW78cwA$@dC5oh4@2`O+ zxvXc^iFgy06J7m^E>7)|(mH;!N##LQ8BIBIvM;-Tdbn^$5qgSD)W)t4IQl}o3>Zx; zJtWO5o4gR8zTYr;jPpR#U}EvcG$4?*tyO2v&z;Vgegw*}ZfNJ@!j59RVaM-sFV+O7 zaNVs`>a?^3mh|WxYr|jJ@J>{-aaJp- z6KG^n-(mHMhhHy^(~{5x2GBpD?Q%mgXQ=qTpCt2W{Nr3UY*F_d5s)B@dycBz&(fi2 z*GkPIZhYsyrBWiTX6nk)-kC32DtAh)*5GCC-C-t=vUGOTovE#7;IvMKGk1jSa=po} zSX8$le1#I~9ZCise|pLcL(%oD(DnRXzZ3!-p?cf8rNgy9 zHaw?Tx1?1Hk6BrO<>;s)53O<395$@HA4^l4IJ6-<%z+0Rp~-MNbryy$St@0Qib;Bx za3I=d^EqATwVCwNN(RGhD9AfN;g)e`ZkmEmqQ_5c(DjGqPL2)ZxW*{O-&k3q>R8luJ zcSD5qz#1E|;$JPY*UFGmtw6y6+BE>65=8D$^{e-gjrRE>5g(D)h!kf;GIRXm8h2MF z+{IS~Yb@P{20ZW&h;I_tGF)Kxx>D@h%37iBl2u5xLived@|Qc5P9-nyZFLWBYb{U; zEHc#t>U3_S3yjeb?jy%KON$OKgLAaqvtul(w05{2-E01@MqjQuLBuP zL1mVtZ%7FpV!zo<>po|)0IHKr!B|2$6+e2*{Yn)!)L0x zv&YoqB8KzoaMkU*iR+lRSfPoDd-sVhKhMe*gAi*%4l7Cf$z#E)*P_ZRZiv^wZd(Hn zSt_0dT~(YjZ>nOQoPoYKtrk*+m)g;7zl_WE&f9-vTZ4wr(2Mya*%Yk>(ED`ek`|Fe zLBN{V^1-BJGzZ%Scdy6EOmBhI#Po7eWipH~Y%`-t)x3YoL1g!4Kt=7>mILJi4INuG zME@9y5j%*7*$@dg`H;ym&>Y zh?MA^>zKv`WTH7%BayO19vhsUT5+|x0(P&a1Yy2_vzg{#&^{U$)Y8JbURD@+d{%ik zj{*4aqmNgXtz_6OJQ2RWKZV-uR`B+nV?HXqeb}7#=WO2+9r43#cl)XY%bagvr}Z}Y3!kk0}W^f+YldQwNcpfWZmj#qsHxOgDAc5h+Sl1_X@LnI{PfsrEHAE33JMvhd92+q=gm}_ahs>XAg!$4Z>){HPUJv!JEtQp_m zBNE%sW~$_Md$#-ksJo{w+rq6&&|%xQZQHhO+qP}ncI>cs*tYE*c0|SbPPS}Wb(OdE z3)anC6VKa6A3ptEdEKq((Qz1ygC~OJ*{vRfDY4WiB>RQL%!Mekc#6h@fhaldD$(5V zGKXY?GY8$IuIZHZG$%>CX&^q`5nG`aL$nr@85b=4_ zQ&2Dl39#*aHDin0?1%bx_2P!zYtpvemjr-E>tNx;K`KhQ+ahUb5i_P8Dn+j;yr6Dk zC)H|U&PHaoZBh}fc5Otfv}%M;4-mwPnrpsjQX%moamm|_@OkAC${asOa)Q_sCMf3f zih-$+()%HpzU=-zN|L39^<;SvAC@gL9bhV0lIhKmNCX!x?^vUIdWrltt9eDqmH4&I z8bV(wo|QHel@={D*gCFbg!K20j3-}nj+G+Ll=+84>XhisI*eU{!rJ9@U6teoESxJ* zGUNtUR*i77HdlkdKIOU~>z#-#YQhPHn%==c7mW%Jt*r?RKoB=B(Jt`RI&#ahoEw;i z>b1?9Ds$8@C<(_3X_7}cug?f+mE#23Y8%`c93VqNk5=E9fL3QWoO(PPiH%y{JyOyf z$dO90&Y#tV}3IaxdZ0L7|Q+7=}6A zLxTQwgsiiXlWx`Q{aBSCO7hj}yZ=**0Rt=%j@^0i8LWrTR?PXwy2EL&4;!uKZdlvMS#z<1kEKG1}HvH)aBennxX5I3aKUB;18`L zwaGeQJ*dMagf%(11)8Lj_BC3)1-3n@PUq(o^bL&$Qje5G78G?|nOO|{1jVO8wigM9 zo+ZyNU|+#%|U<-HJ&YC>|wYR?#IA3f`IYokR$6lzIFu zOM2NmP1XLUb;65x8AVsZwC~IMh6YGP$s>SHO|0y71~HG2S_jvO!Yw`{w+d#7%uH(( zrIy99_DG_0!eUSJV>@QpL{!s607d~o^SbdZ2EQ~WafZtn)WA=Ntr|!1o04jGO4mdL zvjYZ9`&!jS6LQR54;LE}EsRTEw|WjeEX2Wxt3J1{L#Y!tx7eW|V&nk9I%TwMS#-u# zfzd^ZnQO)nlwuZ|g7g#@4aV>_w+@^kuN-Q401WhKKWFKZJ>_qsHJFbvzTOQ=KQ8_M>1QxrX79u$#y;o41r4je0c z947pQ!H_q*+j{j2~^iu26~L(h{){Q3T? z+<5=ue-u?%(0);=WW%Q$)Kh+&b~wWV)W{;t=JxZ-?KHuBTfX0-FF$HY|C8Zw{!{kb zlnhKsT*y^XH!x>p0qrCNp(0zk11Sg!QyA)&D5+kVO4YhTL5eHSR1!_|P#`sioDk47 zbGT6jqZokmKu7aoTwLL5%WPY0Qv}&$mYg=44ptV9l{MK|aPTp0{JOu$$#I)%x%M#8 z1JT!$c)$O)3UxQI%SUMM^#riD6bB>o<6D>Wy-^(??x!3BdAcwTZJQ9Z;r!NqwqnrMC<_uLy}8oW%m|P68Ri; zDCxWF&P6ZKjW-Uj;%}$> z1CnZ%8>n}3BUcu=ov(ZG=U`W6fc>W41N}$C zzd=i)mO&WKr=ARqsdkSvQ0uqa=wtx>9|dZ1{Rv>6_f^aG-yvR)-|>t433^?**hKxG ze_aIlUzhM?$;Gt^@h9^5iRAulAg`XDQ9fr6t^v0`cTY8_e5VD0R><4+ByKQpnmlZu z7wKJw!`I0MjatadhDHGj|2jhj^U>q|GF4IQ+MEk;s$7~Dx}=(?>DDdhprbKnb*9Mj zp%OBz)5$c{{kzcB=0p8~Xs;8WXD9g;iR&W>=|Gz`Wds}WSdA+3osOS-610EoYnBU| z!czBNTa@Z(%CnuDfK=Ah8)~AwS5ML!UIL6`NThoZie{~Hf{xMPZ_c<4P$XJv6|Lj0gX@N;q`jw%JZvK6K;Q>gjP^6pAkd+%N02x>w<;S<+b- zUPllOuOJ)3`Y9W4Kp5MGbVxiD%`3R|<4onrg8=>3CjlzdV}WE#prooG&LtyGXmD<5Q+aKt)Fq*pQo_vFI8{}f;7hd0p#vtX`lcJciE zELS;&)nIir?`Lrm2cwZ;5&3hhP60_64>VLKAj-}mltFdHqIQ+HLBA}yXgx-asUV%i zR2Z1Syk7<(w1lE=DO`_?pxxwG$>6GtIxL|4Ro&dr5ZRpxx?brM%c>XUmP>QDoeEw4 z?b(2?CFB$reR1` zXhqT3tFHKxI-1QNkBj0PU0t^M=9!tQH1*{YE5ei;5!v{$#BbmY!$&+uexQX1o8^2X z5LN_dB9f#ms@GcnLM*kBgaNS&|BA+=BzA1VKp$^542B-^%x-qzo&17kGVZg+*nMsu z)HhXVl)IyhZWU-OZHW~rFbC6K#6mbk$wAd*IJ^y@o|=9+I&y_o4z75!V@uV?VEn6c z*o0&h!5pz993@qt@kxxP15vW9T!~<~E_L(*GlO+;mzE-F&27FcRPmG+*q|h@MT+!f zOyAr|t}$O}3KBjg?Wqfpb&dO0lY15TlBCI21G05U1u-!5A?GdF+_S>&qU*cAJm73{ z6akB68ciN_-Dps_Mi(+`PbKAeH6_zh=pOSx$>S)!sA$OYz$PEG4}~ye+1E?lWVOnPz|aLi z@b$7JVp07X4RU+-?rlP4QQOw{3A(ZDtmy~Y{z{4ZbOBF)HH36;&b+)DX1HE4cPsMk zRN!sst?v7UGRk>MXTvq_*M&Hw^>jqw^*2E*j}}7}PU`IgsQz`K4TWL&eA2c4T$eh~ zCtPOti+|Tc_L9){IAr+D$(rM9fZ@N1rwKz+fb+Hjp;5_SToRFvxNaEQ5;vcf5*-?`4>j=zt8`F{89Uw9;jtTK;L5h!m zt2&?$r32e2v30bePIN@<6j_N!VG)LYcA)kaKrn;rcV{G^3T<3>KWhw?c7%#8n^x~T zis_-5^B&#QE^kJHbYj`B$A=aGT10>QLLd}md#vDcuv5o zyQ|BHVru&09?>doLG}G?(>PVJ4UjXkI#EVe5;`1`K`wDZ@}0DhRBsY5=&T=OtRyU& zA+!r!Y753!-jXIiMJ8CirBib#HROqci=q6Dr5T8zqZLVKj8Fi77-#1);CfSpFNqcT z8%mJ|=I2QOr5Jh{L4QuyZTRqKo>zb4cuX+>1Ax*pLi zDfE&6HC`s3IDJKsCse1>W~Ur@0`p|U&)A7;eOc6a*IlHol*49K4VfKQw-fJ%p-)PDn}2WDZv?M8y|MSCA}!8|xq)9e@5w~-&t#hNFt zh>Y1hxaH;_dvaCE;G_S^^6RqUjb;6=J4Z9A(VTf z{d4~IMQk6rO2JWFf*)l`<>tm1>lpq)Xqhx4h1&w@M4qXO)jgUl{oRlurnQmkCTjO% zz)usWO<_TUdLIEW(v?idK}${OKH zmbdfl=C|wCwuRAz_yiaC5F7&dZ}Jz&+_EDV$uhByFF4yAZMH@-TbN_dIr1#6$_eYT zmvD`8EVE~puG@EiZf~}CB*Q$6%o3jceQ(>oudz%0@4ZRY-MPK~`58jhUter^T<& zUz4-jOM<4ipe9YbqK?zq2=3r1vmk;C3DJbL0_Znh^Ck{JDn5JQ5|ZM9cWOC?Z*9hM z8*m~byEd|?%(;-_C9`aogStsMWh7?+b}6eK*nnpTyo@FB5mXr-*8JrliR}DY+lPWI ztcW=Ld^1r=xx=K4Gmb)7!4VQt7rJBMBOCrO)m3rq0xv8<)m$O}Cr zJTl9|y_UWjxR38xV`+T^K9cnXEC4nJeDpy(IsSrI`CyA~qB(EtAkawYD3p%EX<(E+ z7!;=}IzO)38aLIeu>^`VP1t}=Qs$r-XbVGOIL}WY=Ov>Ogjeb;uE?wT#~!kyxs2xN z&jYQks7O)jj zy)DH_L>ShsTJ0`A zFD`FgL1}0|`!!zxmNmwY+nYD8i-O=}4%>hOng}P2D9(|+eN9oHUc6U@Kk#R}W=u}W zc`(%bb@4w#sjwCg+@lU&=Sra4Ns9gu7#mm!$3#dD#;WtAygAW$1co->HQYy#;61in zLHlg%w9mfu?zJ5mzpZcUCZFAdrCe5hJDMF-Wij3(AOGw(R;P;OPval@BuvaMFce*w zJxK-|2b2aoUX)=!{u}Hyz&@3aXRx zWTekI7uAGO5u7NfsxaOI47pVk*~?h-E- zhJgqLu;h8K$MhJl&NHn^E4j-*K`W?LQTaLwW! zWBSa3NNdy6S$Dx1-cG6WzGI@X>K|Yz#6ifzL*kl!apUtKKzhF2%!CH)78CN+E~~Eu zw(J&OO4y$;uYEyAR1-TBAW&7DS;AePApSAj+?koK+^sP{->R4S=|#8{O@C6p1=bHj zvh(WdZEZ$}0u&F-vNP4AHDip|XfyMswdmE*wz7?v<)wmS+KYXf2AZc=WE-Yt6Et@_ z(u{lPTBiEmVlw*G{D|*5)AaDi}s;bhE9MLvcCx^i6VLtfy4qn zAuwg4sUkEs3lYTsCh8!=qZ5ap_J_!HJ-JL+w3Vcs7=3XF9at|eRLIUW@KVrg!}|RJ zXCT8B4;w-@*LN4c6v*8K&wz+r(1y{%N$Y3?a|es6gdX#;?PZt{xKR+P2ERuONdf=Gl+Xw_jb@RT~q>Kb||*R4$OnPP9Y%1 zBcaXN_>NRehCmZ*nd~NHAIe^OXed7B<^b=7W6zWnWb!Z~8wp&|Bzn`zg~P%)hnQQi z5^=jNtA~;paYja&MS`z z`ZwX}INXdNHod+Py^rvzh^PG+E|pmX2I^XfRbVzxL+KGWN!5AAK>)N?!Ih9*2u(4zg;OnO$6O zp^d4eQBvi#cEfoXh9X5oa!T&q^Yw&kYfBTENe_$$%6J zvbJwVS0n>zx^b8;f6&LYcbGf0XQzJcR`;ZV2Yf~r>l#MtTQ?J=mF#UOjC8@RA>jWy z(P2`@995M>e`qyS4*S|l47Mc%oJGHxi|p>C?hx1?wv~bi=l#>h*A8!)$^E-jWwMcB zkq*#hg@GKiLnocHz$S`z(jpDUuaWUde793$aN+IVa|meB_^nq=`v;Yix>gOF+94RG zJjXP197xltIJ2f_zr@vA5f(V(LhcET7mB{A9bPQx;xlN@K+j0#QW=>@1eJAabID)IKhf`nf~xPk`eLbzeu`}|U0lJGiFy0q z{0Mk1`u`A0GLOu?ZyO|9nA=8v4YXe zG!}{*bj*j$9t;C?ZRTZ3_UJvI85o@fy9R*#rvxpbx_?VdO79z$uN}baxJCi*)B&Sj zfcr>DvoZ%ahaxl1u_sp?lom^PInU6EDUEbl)@bU3+j9HK1T5WKfoCm9M}$tE6Uqba z%y|5+OIngTc2%}VTH}PmnDjs7C`7ZulKS$xnVYGT-t;NG!O9u;UR|xTA>GRS?H+Z7 zqJiF;a=k8gUAcPLqA-W~My{WZ9^|2@O(XIN8aH``?vM6Ppup?^YU%vteOgo7L#PwY$<*vJ}?n ztpS8*@Ez&QtrsJ&4F)DLOt_k$X-jo`EFiy*`C5wjq(k5#nmDe5MjGDd= zVQLBdS$i|4{1jyD30oSuF57SL~=-!ne zH*T~1fqahpCArZG*MZD%#b((ayj0&im|T7@BaVg|=%kvbi?UE9Q^=^4x2wr8w_^0Y zLQ^R=aK07TZY24SO>;G|Ry|u;c3)%2tdaq&#}L>NZdMC|E}8mTQE%w;TrCy#VL+Uf z!iLCTu!Yl{GxsQqB1qMAY*H(kfEp=zc4BqRJUlK==OW*c+;2bR4XweBO0K}HvyV{) z#LOP`EWO1jKLx{>%BJM)c@Ywzyd6N%yNs31Sk4gvw*{+|Bn8(__GWDDDH|^Q{@}79 zvM`f2UOuoZVqNQ(WTEBQ%)*m>NxMcieo7W=2K&#L9vc4jX&jO9T_|L2JVg)U#A+hr zhd`R~Ibfgyx}3%86J=X#Z}xboi?p19E*!LFW2BJP_z}Z`F_bdSS=;3+dq8e&^Yxw0 zD0;SGOG)*2MN7yY3_&@sa{SZ zzg%^qJJ(}3I1BDe!q=0I4?_PD{}R?6h(jfD%1Jil=@z# z2rC?$vKeDPbWbC7>W&9z@UML{mz?+XVlFOk91F|~QF|4xLM~QuH9xg5>meM*9%d*> zlNUXg(uhO>J2o4cRRAA3ZcE-}nZ9OBg}m*E2~YGaxEt{##9l!GX-jGTDw!W6gf|&8 z`9j$9ZSZ+%PxXpZ2&LrA*ED5>C(SRDnXPe)Vswm-HCbZx0#!K79+Ld=e4LAmH4~Z0 zaCwxLw)tRh#jkQ0;}d@d3{=h~2005E%qGR3_o>R(umMtsppGasB^AU8YfiS~qP8H2 zWbHtr3tSOBrKeleM-R*@B)>yA`Q~@sc8lzYH_d_6O|PRroG33v;pge`MXZlq#1&kY z(PErLtUoFw2RW2!wUVdibBE?)QV)Nvz`OQLAh<3|Y~7Oht(Y(#_wDL^#i z|7=C335y5u=|&8W#ThVL*!LZN$ChY?9t+p<8g}DNf4r%wP+_crO0I=Z{039Ag0IP#w+UeOXm-+Yqk50kaRfs9efwoWD_9vH@9Fk1M`K zVK&2AgVes0h&XE_uN9>v)(0W@K#?q7kZW1gh1f{Raf8HLSh@^+-c|Lfg zr*Gj{8aQd@@VNs)4iEc03UoaefxYV&pK)mNC<*p{f22NE6F%;?3T7t5&uW%DfFBpg zoDQB{8x6(HzzYt(F(aa)pg`zxv4^RljP@ivRUm|p{p?^=>7hK|Yx3+;I%1And7{t? z!+CjQhrCiNs_30T3i?11m>Vj%C6=p_`&wgD8H+E!@q&G6q1aOIMCk@a_hO4)uA6U( zs!NQRuZhM>Rdk{73Da4mQ^XaWJT@a?QIC&Th*Hl=+yP`W7}z$s^M;{e_zhAa#l0{U zBQFOW{s4YWO6i94iKDw(H~kHOE)G5Es|wo9bPlGIM{8DWY;prTyf@E z82J3l`k{%8EX`|ZEgDi?I-_&d}x zhphv9Vb&kw6Kr5Xc`#zPDWD*(LYsu7B5nB5@v=}(OPA+ctljQ&heLo@=a4Y4cx!$V zsKY%r#o<%xU6PujNj%DpVPmM))z1=594S(9kyTeqASuSYqO*|(@;gp)ltPB--Mu-Mz{{s)|teEwIxJfvspWRIy z!2Q@&7VLhR$N>lPuYb<%bvc+As=Xu$#g!6rX8ei;E`)60NCWjLh05Af z$;Mwsk@1I%bO2sf9n@3jZ(@6a)f#o&p`2gOku~^*F2QG-9K2o+mUR0eP6dhqb*8)9 zRW(%_H?!BC!E_OBR447lQzBPS=BGnR`Jl(F4+oN4Li)iFtq?_;6bZ-6x3e2^qMM}E zgg-3B22qH_PZnmH^Y-qVYrc^2KD|4*6QLyz-6H`|G7d+XGd||Iud_RaHS{whI+Pn$ z+;hv;$`!f4hlIfLuT1%iJK}pf%bC!X5|X&)&I;=AfpExr`a5RZ@v#g5y-Z&ZN+rm) z&$Hw3za2Ac=dkY%{`_b{GGPGvW4T&W3`w4CW@5iTy|&kYHa^mu`jKe|_RX}nPI*CA z3^~4@Xx6W{HtDdRFFRe$%-V4H+qf|h%!m@1MEFB+r(;KJtUa!+K7xiR<4s#oN9gZ4o|ySz z#Cbu>z}6ge?H3iW$?z)=&~!Ke`UA{(W1Hl^70XUe3yi6E3D>qI^XOn!@%7B zi$^P|P|R2PKT0tz`mjsKxCn7!yhmaci98GHqICMc0Imtz>e`WqO0er5)52zSwPx<4 zq4Iop$d8KR%<1)dVn?k0Z$uBonLmR}O`NL2T;}QKVtFQb0gqrfkHa z0V&p*g0N$U^O)%)heQHo@v9VQM-bhC@LA_1NlKnkCX^$X(&LC}n%w=ix1=+*<5RYI zg#(5y5fH1`XX?2Bkq52wA1;LepNHuxDre|P-=n3=+RTn}hw=VDAruwBks+9HYYA*r zK(dI;^e3wd1fu(hPQBgp9jo0}nVMppu=~U90l^LMdYPxVuyUdY+$yA&l>;gb9C5*L zYE;LZX~QLUXtH8rdzc_H^u}Tdp63Bvb)h+S&sYc1Q$do1wQ?NW(9O_>wn{M)jFLy8 z7$87<#3l^1btOoO%3?Ud%Fo#jotYY+e4lG6)n{;-Q)#ISTQd27AwIEOUAe%y)Id-R zml-4U3!JwsmpEwlpJAS#_|}5A0dxsMW)y53RSwcgD;70WR0V$CBGXui8+8#2iEw;m zfCfy5_YjnooR%6I3?!Sj zMq!a1QyL;pE}6-6;pkvm#_|c-$+YnI8j8-i+rbLp-E$}fnO%+O{zj~+61i{c%3))o zLCnr^iTt^>sfv}Vn#}~J;6fM6ePo6&kaGHf|LGh@jx++3Q~Pd|f(rYkhxy$^bYZyn zGs&Y8eob&f4*xF%%}*apUt@SHlF6TTT3hPlKt6XbZ-sR}ZJ@se3}&q@3~2~GhlN3M zVW`u+-rc4HM`kt>*xUkk67V+o#Zw$x`Ap1(e|;w0I9}$BrgiEIG!g**$P47MphC>L z%!UE>by;y=iv}gT;M;uL+yNSM!+8Vin%QP;>Q609jU7BX7AG1|PTLR^ND=94?MelG zRFBK|apt=n;+EwSz6y)~!oaOF{PXP$kR9~;%6kU;W#geJs;F0BQcya$5X(ht?$eN; z1jp8}(^J^K8PDNIjRDBQ3{D~?8C~B9kkTLS+9_Qs%x@>@6Zu}(#vszFK^vG?M!fx=B^u_dbW2o|URDa2I z+sm*jrjIAeY6(U@k_!9!^7^7_CFGuz0|Mo6z1I1oGs8*1bl9Y9qpg%s49ce@!*mK& z;{$@fr&@AOjos0Vp&f%1Fw9Ebvrgx5vsk!TK*NH2gNzra1Uv=1r69pkew{q5{9+j`|2l^YDpJ0|5o)p+SBIeDIeaXk< z4r%VS^Y*8BDLyzef4f6lsc@jP#$2z9TUoRow)jNmH8|B2Hohb&*{^{aXX)=yvT_g> zY5s=;+OH5$Zfso8y&@PvqW=nk%=xbn!1BJ0L(+>lZS!Flacq~9$^sG0V8?bll_&ZI zD3(eupzU3HONk5jzj|BD0(SWWdlITNJm5Jb$NskA)fiP6jH=+M_+RiiwKm9iQ(oMd z)-v#~3{3kwpDutULw%UWqK&-?*BxJN!x(XEMlgwG#@&cWTQ=a+7WQoftFau1{tFgJ zD-*Qv%o_VJ!oC)xkV~GNgSux&jvn6vKYk<=!oIk7oXj*)gnZv*+Cis?Jc~e6OcfD| z9DY|n#d8)+(Z7ISNT-_9d+E^^s0ZTGJSAdLAM74F6EoAVpXO7Kw4eqYn%5d$AdlA zZ??vsyHWD$0%Tor0s?mxL{D}AUT>y*^fqN#j=HFdIiMyK5GpO-Na#YE#o=c3?zUb@ z{_>;VP#S2hF?w*^TBLRqzY5 zK#^3C_hf6t&7QXLq6b7q9R8Mo>P$2ND%!ON=8hKbT#bt-{AgIv`fAa5GCHXc^;yWS z9hQ%t#+uT`GN!GU_iGGLe0M+is|QcnEkf5#WPE3=npD^YC?u#e7m6xvYkkHR3wd!8 zl-PuWx=f7Je<}XJpmAii5Ony5>)E{^x4zlt)OHv>TfW8I8fZ*WkbWc~dIwJg?!6XV z(Y_c|BJeX~Me@fI-l}|8Bfk5w^=T}3W;;jGb6fj#oo-bv$M-5Ff<5!s3z8uvU!VxB zB?5Utfs4x^SO_{-+2rmYihV3p>Z2r&TP$EXJk*(X+Xk&rtInm1E7-iPnVt1<%*^riyXa<-q&*~sHq?Q4fGEnh^ zawB&504$VT|4P!^3h5qA6iQ*8iNnHN<9=Sthb#6Z%SLmafR7(?bB|r;bDzVr7Z$TL z;IJ-q6cbD~`aO!pLRTp}V;~!twzCalE^Znph`3#gsZV4;9Em-I+3?PtHYLX;+dgt< z2OMX@Rz$t1um95{!TbjcrX{rrt|9(q)Z;)G|R>?0d9$f;<|ujUD@TI(C;-C)erEZuK6sKjnkMN9I(e zn6t2EIwtmY$$r|16_(IXiAJR*q9{sHfBd&4dk2PC#x884!XD#I;+nqtd|pb0`V(zB zcNso&5pc~S`w2v2Ky}Rv%AG9ih!dErG(wAP&Ozy~v3-YuqyH=e^4X0V6b#mM zxVq~#{h_PD1br$>)om7`MQ^9GrBI8jez&aOt(2Fu5v(F=1_E5Mt!po{;45PqGry2$ z8ESYXY!KV-eC#4z>c>n!UeHC5RpjBUJVrdb6|e!D=yOK(D(@swYom1|(zPZ8C&vrJ zYok6=Zh`NyV~S1U>AZ@ebpmci%(jEz*XO_L2Tf~|hUa;cP21sjFm6m;HF0=9b0AGj zzMTbvxfh$g>l>d@X!2;u_I`u2K2{?>?!p>oM#GO{E`Sa?X_P%EKDu@6i=W2-$^kTD zYDx+O9~Xa|S_--Ef8+rC$lo4knKtVEH6^oNr9IZ9l_xHZki4fAmEcW-pI6$88 zhzfSn?!M)>J;zow^-5XSF~>_H>p8<^5jE)!!*y{8>B6<&_%G}= z(y-%Fny;GBAu1?ltIe?`C8iNFSdHvc{m>lHki18RUxJen|gwb2k%AaB4? z5_W!R_}KhDZ1v<%>-Kws@$lgcv@X!KLxx}usPEHiWCHYUOxJXn0#uJk&rTK%I}(QmjKEuG1_OPW(`tZJUY z8bv*|h30<`p&=qcR)judY58%m^H5CfPjrekkdTNR9rFvKn&QmO%dP5XoI65rxaxEo#g)R#9+uRIw#>q)!AvD$*k~ z;Jc_~_)VP&OR2!XL@MhgrxuK!e-bWXs?48>y~kBMsW*OblT2Z1j#m297q%<}T& zQ{MFi2~CX^tRy6$WCki5XVINg>OMjdI7^^qg4J9&;m4WTfZdU$Nwiy}Ts&<9wQOnH#?(6h#yAkRF&wEjlXA5j)~Q>;)EH z|EmTUM{$rOrMyr=%1K_g#DS0v8gHb!pj2JCFIoG}C^GtXl?uYos)M?3k05pwTy9Xu z8O{Cl8fSlA?GkvU&Bg2XVoh@xVt$*K zkPp4fd$S<9BA_1)*A7vjNtJN8`8vHKBf3snO8L<;;JYtzX%vA-OiPyMe$a;T_d3xM zJ$W7%fP^x$O0G{W)MMHm1rFTee3D~sz~|e$o)fZ?N+b33F@efa%3K(ueWHhh;{&S_ zf4r`8(b^)u=&bOf-3a41D&IW!;|QA`TI0C_uaEx=dmGa<#4#Yx{5yO(Ik|Boobh=T z<<5X!G;&S^PQ@?~X)N@T8F*7XDr~4<5Z$5BzUop^zFelojTj#e!?Qo>qxS(2=&Wi^ zS3*SUnllZk%L~CJ?aI$K=RQ24(Q;QQ^4pR$tua43Yk9J^ZnJw55? zOQ|&&+?WE1RQOx)pkqsGZD~TC%or(fQu~%FmDDPV4k~VJ5DA z9Y;^an|w!4j-9B$p6BT1VR|+drsQ}RlkqZ?Q9?psq^-xG04dd(g0T|Bi<|3U#YY2V z^5_+7BoO}tq+NmBV%s!3z$r~gE-b5-YfFnUN<1i53sDNM*o$Aie7Y;-T6(4)M z7dzE^Xfij$JZ1?&KLmms1In_W*wh6prX9Aif zFz~`;4w{k%Uvi{9a%o;g&^JMofwFWRJlD(6g|JRG5{Z&bNGv-b`oCj0kvWg$mjocE_4p*w`V`g-)o))4$l93U-$Qsy zGQUv-?TtTBJe~w=z|($XC{$p>Ox5+FjUi{a@Te@LH3`q#hl0>#JjTKsYk-{s69yj` zrX%~`DVdt2C+2^KI^xl+PvSs9LqHV#fUL?Z1w6{U*QxRC!HTzu%k+tz3R(RdIE7m0F6>J^+5sMV-uWRt1h3O7<(y2vZ;E#p_W}}n| zuBQ+)jSlWNX$VZaHYT>VllJM`Ouo;!(Wy1ywDq>Uv@oVuSvT(L$5f4<(lr8cO-K%_ zTG+V9lP+ydu3gb>b)qjY2W0Ha`mQK)#vb?()XQvWo#lLGmyn?%;*V1bRfLeyUn?~7 zWBDw}xTTKJL(QC#m9_HoPzq6%io4lA%CFMTU*HO>$o+NGJ#U9Q*xn~7swA0980&2M z`$qd_m5{O0k4O{(tVdVAP8a6=5;4EuH0?;$a>aUOG4zC%h zfYWqqs?N9t#^=N3f|(ZLJLdm$0Khh|+Y7_WE>yc1wF2#UKQ#S&w_^R+K{!W#8VGad zv=Q@A)l5#9lR5Hc8JM+LL9ybfGj{;Wh04iRzpVi_-+dF*TusK}PWX+Id;$stz|g^S zO>-)(lbqju?3A#Yb*aVKqScBX!1x&gGsTkv^T^7!VZ5R9lGq{5vG{QF5U0csXXfX3 zY9|>AcG;BY`E?_M+QSx;#k>!%p2o_PBqjGgFyo+r3@IgKdFK0P~U?uC3pJEq_;*myYFo7bhZqY z-_*c`zzn_%t@*7P!sfV83gd)}3%Qn5@Yio@U>UEah>|`8AEb!|R)~E`gb!iUf?dcl zOD9Y%p)X5A=7f)?oE>pPAw6Duh9p{QPCxxFO;A!qyd|QF1WAf!rH|_+1G?x_$v>f2 zC-AxR_6x`hb#9ysy|4r61Xrw>=|jx+xkJjuS&!)?a0H+E~ zwb;sWR^YmkW~ISQaV zGeWS(@>~mdDT^!BRMbtEOd$d9sd$&ewo*M#)*{yrb({09;I-z{pz36=9hao|IbtTp zwsghaWWnDJTN$$%9V>y|<4cVgBOdK4Kt@}?^`T&UHWA3Z-QLFW)a9Shey_#EJH5)a9J==_Hj-STq z(HNwD`ZyX_gQ4p4pzFspK1EVZEPMhK5YSmHhLtwGdSs1*Ix#oxCF7zl3?cWP4m~kw zoJuVR?sP++E=KWZ)0O@_{CSU(CEsXf1w5)KKsO!}wTCAH|C$M|Xqz9*5%80kq`q)_ zuYDSm*4K~UI^R0R7+&rv&AI-zd0Hi(iSUSqOwDG?OmL}3Xc9wNQ)ZyEiW2xJ^tK%$ z;pd+a7kjG8P?3vX@d$n)dGMt^%l1|vW&vG(JXTc6?&-q27UP++j|sB+rDg)wF>?!;Q@635!a&(;SeOtEwehN%wxU1U6 zgFXo+1PqwA^g6hL>|@gKh&`1za>d-8H%gE0mj=KSvt|S}1gDw*hXzb&Gs-cp_koK4 zO9NDR#hypa|BD9B|4Re!XLd`EoI{y!1U@oHD#aY7jgtwnNUQd8#;h=efyy)sEfGag zzd_+hOZFa2v5YO4RK;C}`@{|Z`Z94U#oB+`EskoZ#xr0B#kLE`2CS-v?uu*U3S04b zMf%(!D|5H8MV&3M4p1^y-;g4IK^HNHB6#%g><>_8Vx?{vt8=e{km1iJ7yo1m+(8U0 z%*A{AKEH*l8i8Fc2IR>vf^V85mV7%bjsSU|bW%%e+5P>D1P!d{pnJj1S&2HldJ49X zJzv=3p)l8Jo{`y{g48=;|BeF38~X6$zil-r>~H9Zao2DDMpJ_gdR3sSUn@h8+R0{5 zr4my$tU64tm6x{_s2gem0$j6gYJ)Q4D`5&VyOC$DZFnST4d3j3=_6bz!pJ^f)n2str12ouu_6Q~&kw=-BXr8#4&QIj6qCl={x6os1^5qO zz9S@`9?@MNaCWj39Pi6i<~E;`aZBd9spIpNBS}j7!#NP_jo9=f|L7cIlSfOI&jY;G z*(&i_AJ!lfI({5;33SMDgUo61S+3Ji{0x3@$b&f%6(uF2kBc8pErt9$!KET0+}O`I zN0m0p(;X(Wex(EUZ>Ru=R#?u&0^ILXpwz-Rpp#vzPkO9mfo5 zdGr%k)wHEx!Q(=9vfpZ1@7uhDZp~fmpvKkO){<~rQT5<%6nz_LFN);AKs#`(0e!>P z_M_n9pqp#P59B% z*0b*hdzN%E5r~Y?)6C(dIb-x{1!PTR|AU@fN^5$aIHIk(2?wcskWd7G&%@5{9=|yK zdmf+s-}CrJsNF`S<5?~Vsf79t8t;T|_B8>&*4j8c<+&^&*_g$;p^7w`*Qm3IAhj+7 zQY;3L1Ey#vktnY5UA;{a|7KX%#eTO}*B*=xiN$NE_d!Jujn%#^Nr{#BoTImJv_;Tf zbwvic3yen$1SF!H0WBw?MN;0%Xgxv;x{pTkBiPVAI4+@HHTdp(f4+MsZRR({P5ZI; zZ`JcsT74Uu9ej1N?js%j>Ngg?CBg5)+w{sB#ckjyIE1R+qP{qwr$(CZM(7E*tXfQvC;eFob%pq+;RWKo@1`HHjXMw zH6^rS8dBjf95ZxqY5y?5$`?~vaRRKo@|Tq-?x+8<@;?Um(!Z>{+`g)B-XXOxD;=V* zTNR|;b~NdxBbxHJx|DnFH~2LAG;Ur#=i&zEyh1*Vn^%eEZ2@0~WktiTGJYHw&Qa?6 zelbD}+2Mn1uNjTb2*6rl<&4i1GrosZhXMhZc&uPC<{21ac%$iaa1|s9t@+2ZDExIKx z;FZr@_s#cGt-yX%CF(Z4MNU@_xN!Yk_7H%bk7xwg`3VEa{BL@g8CY=lys0SrnQ4;p ze#6ea3s?e zEX`dN$$hhS!W;=0V56s%{=0zer>S5x92Q|G$F7=pTTA%&?d2OJ!mvJv5X8IBpi@Of zxD6?P509cH!)0LCOIkC&y>e4X|d=BlzB{r*pEO9~x7ZD<~<5d$Q zxTPgYtNjtAJv>e!+iz2sbk%-{Z;#4a+j7`Lmj49Xx-@^CPmvDq+M}mq2h>2!V81D>y;XHmE;uHRkJkJiBoXE{GOIAYEjfUZX zdfQF$*q+-}=4g>uK}yAv0gpN$Inh6o%T?BpX#gMI`KKRnYBCAMM1QG5-kiTMr5og( zpus>`yhvH*W#TGWEgNM(NhK(j84-a9Na?4E z+o*9%b@IOHt4?%Zt)iM)W4@8-EK?I!z%w{kkz7%^0d#9oZRhzm`~}1b2%&SRVHFWl zFQ6eXR9Fe}N-xJ+iV@KrSw7~ubASXzM-35Ho|sGwcvmmn(SHNS2WSY8On7D%fFNTt zbLeUicX_pUrec9B$4Bc`Z48{81aeuVhZhBlvZ%!~o;KJU|vsmwe!C1QJCTDo^3FN1!5>_Iply z$h8M!wr{wNQ~AN*?S2~f8QO*8JbOT%ko0Mc9lX2WY|wBvRH)e)h>H{wp5kz_^Hc=U z@EMn-)S|LG2HKBj{wQ3kpjbYxqK-zkU+Bh^t`^=Hx#boHS(APp4M%ANc>+QibZL}~ z85UPMIZ4IH--tWy+oaCyHc3rD;(v>*z&!;frZ#_b2 zmp@gl*7%mz$kN!v!9A{`s-6i08_uk&%gI^rTv^tGwL$XIL`CfXgX@PAJod&n|i?#gI3(ZF7}4sRPUOcC9qg$LCl!FX)GrV0y_w)-2V1 z@Jy+$DH>Th#t+S=4G)=7%Qm8{(fS?KTT0G2a)<8t5tPg=Y>ZWaRKElG;E3bA0@cq5 zYH#K08L>Q;G)(eaX`!I@2+Eonxv1H172mg`Ka7rH?l;60UzGmp=J-C9gqXgbaa77M z0wBG5W#@|Dx&k^z+7OGPui5DQv+>ki!g$!EY_$dKe%OPrA=`KvRow)duMb9MLCw|P zjIjk{2^hvsHKkE!_n<7WOhDsAe3P69r_VD3yRBf@v^?d#KvU@FyFIQ$*9Vu6FVOv% zCjn?jHCs~G*+n=^nOXlii4M~KyhRZ;!w*Z}>Vx$Bp<8Fo}X4T*)lS3{VjDG$Z>KrP?o{o#{(Ys*9#%$@=4rR z!tqCX06^!eNUFkLcEz~lP)b`NU9;7jR~NLGnkVVo%`OVC~ z8r~875O&RjxD{fs`;FU1hE4ecO0!vUJ2nF&eecw1bZM0D2Ct$!%4PUn9ftiS=EKTT zmg*vo)q>!6sLuIXCuW;#1ENMW6Yfsj^6WHTQ|4zSzD@ZI^d4jYjVyNoXeBv*_*4^a z0fua~F!rdPYz+}iYt$)R@Sm#bAu6*(LGY8>DEF-VL1H6Kb(MVwQmo6hY@bO8Iopb| zq@Evv@ar6mpn}xrfh1PE9j7VE8Zm_?zHe5- zS&H|L92qH7W1-EUc7sjNj#yuOsu4(o*m12s> zAG?amB52!g#w|_xS1K5H7|2nY_HQCgSRp62VP|$f&QE`37coj~cpMgVcSdJIk5kXc zwHT#kNL-QV7v`@b%LzFph6@kA*#Mb2NVu#q&J9zvzDm}g{hCxvyOF$X0Q^K^(_*-? zk8aN9YaikftN4pf{>W8*9m)AOGI}UZMKaVB63S)2tJJ!EvE|eDcX0lnUyoXe#D%Zr zVDX-Aco0$6oSAO#0=_YxPY3O{W3Jn(O7#(g>oO)loKhzt6pnKxe24ivUFa@L8tKTR zvW6b0-KoAl+_&@WEyQkAUYufrE@m&Lo%~u;5A{xj+p0p%rLrTWThw4R^DKC(xL$F-gCew11o>Vgq)T<>$KGsWMbi| zz;RpAL?|rYn1BVt98PB=jEcDzN5ofYEy>*LxR3ZG#YC&z4WpuhCirNHvl~$HA{AKf z!i=0l`pLjo*D1y)ST)XwCB~=6$2h;%Gm!2c8-v!=JTDGk_zDSYc06zeouCx6TRcoB z%r>ss%Nel55DX^QAhGZ(l1gZaX2fjkUJS~>kyu^CCumf>^0Ouok6Kvem)%^4##SsR zf`3fQsht0k;tQ^*?~{-NLPwtO4aK@pFK=w65?kLGbH&SF9HQy0Q4F!emq|RQf6`XOTVYPsqQj%tvua*enY#3&6;xOY~1El zY|kR)_L0ld!XeXpZ4UDOt4f>HHeo47RLQWASn~+iaX$`h|D&86XBi{ZwK?Auv{RQm zv`1w#UG|xpYCK0`RP1yFyrjnW8Eg>@Gxx&0|wk$USAikf6 ze1f6Dsw>#@3Yl_0VQ{b4OqjtOIBU3v3pGZVK_@ml6U7PXX$uDUd@rJ`pg{0^vQM(E zkbMojs6+^1|Flg~Nf-0{%#c!>+y)n{i!Xd0pR~OR+UCj`Iu6rq05wkFh#G3l?jhzf zhkqq#a-sBayPn}o8v2NGHT*@|F$FdkjC-Zn0Mgzs6(?Oh@*kXb#FZ|JKb;R9wmmvJBcaEdh*V%g8j^JwGEoNjQ=lbV~@Dx9??U6 zN|Jzoo|-``f(QfKb9F(nfJt}}-1 zrqvv=H8yCGBtr}F&}W0AWqU5So-ud^*cv!1Hu%9_!5w)ix9&`4JL1#n28kmvp4)O9 zJ=)m~$nbZ6Y(H&leN3$2*nM<7uYWgV=Odfk&&kPo((yB{HkZ#|NE$xLDfG{mvj{70 zJ9#v^iLelib?2=ShlqRd@aFL6#SIAPDF_;DRl0Zpq#4rpMLP(;RhbIm1(MW(+qI$(FF>l7sT(2n7Y+0G^!jy1%*7?4`o!|L~6~-r;oa@-Epvy(vIWDG5V)=nr2JuY7>G?XHhS zI^g}7Qy&%7jeukO)^E;)_q+2+yRI|bI=T3DbA{(Ap{!&ATqvF;*JC*&%Mj?K{hajl zh&cdcG2^FHmu_&!=npqs4fpo&O^^37xVn#BXuBvhiqYxkm{~0&x_Kr%IetLPomy1UOmH`jU7q8PC z`~ACct7#~OMZ5NS9mH7fpPD#^4W#Iw=^Fh5h12a5RtjLk+bF5VJfzc>x_q=FxP4UK z#>SQ`vrq0n!mV^mc|RoSMXr?~D`!z~E=YD?N zvT)+p5-7>r63_Uxv`63dIbcgo%=7!+BEVQqJ~O;boerNZe8L^}^6TyG_G7?`kNWq< zx&LHCt*nuswDAq97@oA1{Cqfo!IUIFTGV6n)d)E{I@m-kb1up zo&=*A3Lp*-RQxWsobeRD(TO!5rS=y(<*si!ho!w+-7xecsu!0OyB56C2`IP(fZCY< zqIT8F7ivE?15o>ihS##C@P`hNthUo1d)OPZ`I0c~g z-v1Z1&D)bW7xVvz+9v-)ZT;Cv{Jr9FCg2&$Y4acO=ZQqEK-Ow7zqgJ5u&vBa3o1)} z74awFn{sz)W$$}&CJos&WmNC-Jpw;9f7(z{CEz2i6iZ2FP*8Nyxcdqk8YKf*w5e@I6Ly?u;}(_44|h_jb%D%bTF(F zw1jQtShof&MCTA3VEXXjvoQskZ440&g)Ybvp4dCG*%)aMbBmV3ad@=#P!p8%n57k* z34=9HL7(!O8s0noRIi}L8HoQi;Rj)9zE|{P6M~RF7qEZ|`(+@ab_b)(a<{s&m1>=E zA!0of{70wnq5#`pU#D@lZ(g?obp3AiX$#|-Dh<`B^SvWf;CD3$J4#tgOkW+}XS z%!9lnjH9cn#|H5QRJHK&{t5EJ&@9MMQ_VAB{+Sz^Hm7+!`E9`|jWO*Uhj2|9tYs=R z)xWrnH5^=%H_GZ*P%#kAy1H)b>!7I2c+~}c-ycenvGJL5Am(s+N&rmFDA(-wx7Xdp z*jaQeUbDz_w~S7NNOwb%e=;ok7h^Il1uV`@a;}+y>L{#ITApDp#YRG^$xJe=Zvo>6 z%(vu}2f#`@ z=Xpir`Xe{D$qmP&Yt|+*0TFm@;D`Ebmgq>UeXM^X@RyS&!x8U^v-)y|V&{zuL@X?p z!L7=F<6l5N9wn7O?|W6sc6=-fGJ3dTsg$DWqlwQSp5EfLOoiSO(jlPjFIKt!TK~XA z%5YkvVxtAdwZ#)tjhqw;SPJt8)+NhSUmNH*lwow_ftb>;nKA_)pMjVOte;hBllS6) zdtkz7EBIl$ne^TR0BIjT7uo+nEcC`(PB2Ekm{ZF}8DDU+L@PA&4-0?#~IJI4j>j?i`tVcV5+^c-$UHk+X4 z+cyeSUtv5GDAMjN7njFTwhD`EU3aqL1^8~Ievaamg)5MX!d&-z%Z2MnPz2?r%0a?GRmHUmxS|HMc-I<#5Yv?A&h>(NTd?U9T zmVw>8o)kT_G|qD`Ti70Y)#|AZ>3m<_gKI8Dc^v7WCqNI=$@&MS>k&0%m~i={*}hOZ z_p=b+recP24>E*Cn!6yb;{QcyYay-CJoy@87<{w^EvPNEoG6tZNeDnio??Hf2PrPv z!ayZrB*nbR%qG;r6Z&& ztHtM-00H=dDGD9VoXPRyk6>0%yP+?XuK7agIRHw>{e#jLN&lg=>vCaHh;#cFN&}Ps zgVG=wcXapIqAY8{l@l?MRCEGZC2{P;ZkV~)oV@(&Y*%CNF39V8ziKM5L}l-T#1+45 zxbGya%?0)-8EjUjYcB?FkSESjh`4bt+9zqsqaSl)tr&R8^Elh*DZU6K9Ij26UN9@2 zS^|^7MDp&DG+{(=h;;3U*)PLa&~cNmvyI32YHGO{KrEuZ6+dbOTd$H5G{eIssDgQq&P^!*3?)-~kI({47t> zU5i>D-M7btyU*7Y`?B37g31TRtzFs6++#^$TBEl!+4o*vbCg)C(Pt;WC}&NIA-h#h z0}B_rM4;<_Xki~YFjpZZnee% zT0cyzM*slR>wLb_-k!ycK5-6qoNSu2%ToB9k!Sb}eUr6yPM=btE^X4 z`9*ST9WNpjVI5WaIyF9)EplR}%JOEA4r*bp48p;y=L({XG z4%zLD(XJ@AquYnZIsec!H!!L1BsaAHtQCX+;(4t;!A$*HbehxonO8!mN5jJJCO~%X zWu6}Qu+z;lV^~L(8A&lDBh|XuZnR`27D%GtkG*;tWm6S6EB5BYI^})M{;>5gy#)n$ zB0}tvJe1^?*F7Z$WM}t3X{3|0fJ=otb1LJmNP>dy*oNhjClc$#PbOcrGBb3rmpJdCt>z?i1AP>gg1`R)dBvYroo#|<-rN5F#Wh$ieE(L&f@D}flNlJA zn14*X092AXuayK}}cZe;<7R){gZ04%}?oMb_duyB-Yug56$T za+zr^DiY-e)yZWM6OS5eB-M)0Zm8+fOB@PNcGOm8omc7N{AeYW=dc>stG_lfcq*OJ zdiUz;v45-3>0H=rwh1v-(+O#XLAZyz#8wr(`3weFXq4|r(A6Q&;j;XQ*x5)XcCXr7 zKBD)JgokjIh1Fg@fW|pKWvJHBVKU!A4$^8DM8XH>aIF{|7>%QvgC}Akz&%0}DYn|D)Yyl5##RiyiztX~0 z)JLSE{muy}1$&MgE(CA4^+8{b9=SY)1kb;*G71KXEBud(UHWBc^q~e#(2mMcoB&+h zlkw@v4d7zj>vOUHxVSZLVC40)Sw?7n-zgCtPhAH6Sy!|mxZG&gNI)X84brN@K{o9^ zna(pLp7U}fw~ierl=}qsZJmeV@UQpb(WB{Y(W71x+=tb?v{vt;x;H^VwAa{658IuU zHDHy_XNUf{QOpH_q66dC0+C!P3obc0FVaW=&>!4YNIxzIk-5535>XwgNG$eAFvLs{ zY$KILrON6fiTV#l(IIaa%|N}cTzK$*x$x{hn|Ho3r+*~0d={kLS|I7BCp7;mfLxGPO{)ffBhri+ae6Q16RbVP8HBt{F z<}3sXm}(NV&hp@&c)tOX;XaklVi)KxI?CN>HlY5ir>-6N;RbgMYzS|_#|dq~BmZlM zTXc8zycj_x`E~98i^X#EpbELraxqZ2W?tNQe3;+fKrUg0_VNK(y!cA>6%D`VJC*j6 z`xlGRe0Y03Fdgz)#Puz6 zAdqWJzb2zcQj>m}t6H+5(Q84mR2hkkrBwdJzr0apb-I3pfIR}BpCg&S^fNdd6uGyl z@vU+GRl+~XaO>AbUHdKaC)EPUwgsy7Y54k^&L|P?Dv5D!Dc+| zf$~&I*3^M%UU>P^ZznxQYcAnVsnY;Z>=ZY>#nSFlGI;-l?#C{s`4ghjX*8(F0HOVR zB{70)TGE8tl~B#$@)7`wl_gzu@8Z{_wN?TCIqAzkpPIkkE=~Lk#pq-E=*vl46;ktT zt%SU<$~J_YPo_uSS8b&veM;(?Oo`wU?J<~(;VzrB2lFD@!RlkUtdZcHAjEz785~5E zDJ4L;GTHUXICB9148Ho4m8uL8 zvs1S9r_bhvmT6tGZtI316jBQ}N zh9U`{Ez3vCgbz03KK>=p)jg#O8UKcoR_EPXj~>H|t(QrstvIdwidBL+A-*>{K@;Rg&X7 zESnEAfN^GzCnz@miiNXWQZ)i%;p^v9#v3l^H5;Lp82!!+TT1r~+38Rk-f=@I7Fus< ztYKtl(BO;xj^heU1rb#=RLc!>5L2eZ;a{X|YbZ8rRw{Dhyhw4?{7HBx`nq*c{$Al% zE7$urFU0KQ0;@9J=x(TOP}{rXH~0hjHSrKd0SH4M24St3nS{xx5l|LKlF16oI3j7B z)qfz?4@^rSb9HsR26V--fPxOIPfR<39?XQy1T@UqH_Lc4Siazc#j>yoD2zpgWlwxD>vakP0f-@&Qi;L zb#W{?m2*`#A$i9H^oypQ=YZx|NjnL@`w|cj|5}v;YNn!rYQM(5z3^?5o8Qn;GkbD& z+7?Hn+jIWSz2gdy&T0VZTtek(1CY)G__kD)J`5?@w?Q@rjbwOvnP`g?FPq{{C;eqG zbK7KY+d|d$WQ%Y0AUo+L6S6}BRwwQMpn#7Fka_x-u4Oh&No>$#F z_tF#x?R&0O_#2PAAfO9%bU8_IBtt&x@sLJe3|1i6*l<_m(0HO0ON}6Bxz?A0mgn^zi((!)3Ev6gODxduIUf!| z>oZ&lP|C(0%!yy_##oK_1`Ius3%n|wdd4%16@Xu(h_+z?W%2U=%Hp0a#{7-3Nm*y7 zg|*4~1AkJe^VRTjq8m|YQ5ZxpXh%1*R5H-VXQ$?|>@_veNi@#qWR-uI&_<@bTn+%% z8f$vk#pgiW^5v@c-NN+e5`0QOZTw8a^YWVa_p1VRia_vPJhr=R_%ku zo(9s9?Ljcbwa=PGnpb|U$)TzV`8P@7TZsK(;^B6*{A2uyEp~EQ^}hStLHkg&Xib|D4{B6^o0~ukd%*)3<8Sk>q)V>HzMd^H6EM+aGxUx6 z4VfBh=yXMei-_WUa7nVhgO3(~c1}lFH!6%#w0&GKL>+`JpLm|UY9ZsNWz%B3GKy{o zXy-8=vAe(Ya@HKx*Bu-H?K~#0EE$>#0p+sSwQL2@&UCgbZTWwO0ou8!@HHNc@L`$< z7HzGN`Rcj%#OWycva4p;@Cu$bV;smac{Ymiuu$4(RIt~D{oAqzBYC`+`B91v z%*QbNVTs*^z@L|kBMk86amQ&_zZR?uWIaFkJE)~Bwv>N@;duCU}C)f0}ub zUtSbHF_en{eeq~>UhQjJqk1o5pDO&N`u*e{rci)(z7hySbi2bg%EyA0X4q_3QSdMacSNed;=Pv$=?PIE1A zbu?*29Sv3zX zTK+PMq+im?HjcSa;xLK~iBLc-`V|b{%awuq>WnWhOx<&L`X8-%0Z=)MX>UM+i3s4G zacxcksH_J|)LU_3(M0TYP2p*>hIWQ4cIM6YpLZ4^39t5`Clxzr9VZUJ#d-m&p&BuV zdAYl(Ncb6>GaPh$G8XvA=6R1;**gQo?6-l3&bdS(XK}$~TvYv#g;0$Jk=93fZ1GhZ zFV8$0jQ+1Q9$9XO_#&~?t1^phQZDrjXi@|$pS>CsUBZ#~ot3}C6Zd8nv_Wo3_d4U) zltz(le)?mGk?@>d}y-yB9ijxt+ zybqHBDr(S2zFwyiAHHe-7S-P4g4Z06$4OW9)TYhwcI2wBvAGK_|K;0*$p?d`W_z8- z5^^g*G(5XC16g5zq^l8R5b!n~s{ZpE*?;Ewr#E|h5^1Nm95zjCJpJEs!5+WPR7sqs z%!G0(nO4&(pCGz!Peg%lE@125Nx8wFD{}c?lXA$Pm648!&>Hj~BxOxY2zh~- z1Ott|R0fe~jG}8x)}uVGNPywEu9{MvFa^+$83*UUYRoDEy^n6G*A%GN+V#3g%m6FK zC-|?7H+s>@@1bl^UVae8$8#bo3JOGTX9o})8o5^jfO&@B`_m1rtb_G%L$1W9w9iI# zAIhN_mwmsi8*Zhx|HaC{Ww3;52I>G-R!0B0(N!K!txQ{)zHjGP*Xn}o1ZVeQk8Nq3 zDbBJ@j-Dyc!b?+_16_=b5`nLB7`~Z}S8DbF_An-tcnhZ1=DKc8A z2GN99u?Xl0Z4elJQT?=So$ylg$mGlj6b(m`ZVq}yvU=tWj-7}h0!$8B!wH)$K*(Di zcZ69s2O+6Lb}ND3X5G2ecBK32l8!I=LZc5LgZ{c8Jdn)hk@Bh8MZ=kw|)?Fp*e zJ&z-Z9USCImy!A7s zO352zIrberF}q8^pBysE(2;XghWAm%O~R7WXv~@9(c!5tjhr3?R;wxb>E+@Q^>VgD zN8(L%J z+eI)rv=u|#5{4g}fKp)BrAm9uVNHVS?eVdxr?M!uvLXI?K*W%5tWt0faI7R zb)QRGN;ww#(C+7!=-)cbhaZ2@o}IdJI3+haS?{^UcMYZ#Ko{bxAHN;0L83F0Zlfzu zP-0?SV4x`>{TcA|6k<0fwvoVNG=_VtKsBYLX0Hf!*`Rv3;FY5 zH@wnFM^-X4JJI=1ItNrH2)>al(|l&(Z_)Y(MwJ0?SItoVj)Dj&?OzGO<)^E}Lk{G< z^0z5LF>(sN;$_%&tNtdN4p=g`jR}+IosVktE8NV!*9taAbShp1XE%wSMJeyj)n&iD zXS&$YT;qQu6ITr?(B#P6F1*R1cZ64`9;LopC%lcSyl6*Y5LLy?t^rGyg=Br-=*Z9ouV==vY@VYRaAo7W&2;z(pT#MVr+4?8oABu9o=FYyV|-_H`w z;tRrv=Qg`x1w`pM_^4d-&aQl))hR9>+!&!kg3#h~=QYp1g|uxI|An?YK6vGZ>QhPL z%!*B3yfcEwTsNpQm_L|$tA3l)IT|GZNb%7)A67Z_eQ0+FJ$y9b3wwV2QChuv`9(6! zY8PrY$&q%lFkXq4$DjOt(Ng{X(-+W}sjzG?6P%A2hh+8DyOI`SPuC_M^FUmC#6?LX z??G|JL&bj#EEjg}g-`ex6~f5&|Np_|1 z$`xs-zPp3MYDN$zE~|gr9TN#JNeL&cl7j4ebluy`n%r8(!@>|u5$ReM>Aetu1FN+v z0;IKlZ>Lr&t7=GTCKAMTEhcDqBBUYkB%}(L^JFyl{AF#5kVcakgc*B7iD*-83Lxe3 z$qe#bwi=ye9(lkpxFHFCk@0+!=j6JGB5}2_9A^v0G|0n*q`qhxyQ7SfV(VjJNCK9} z+w}$qIOMVqO>G2dI>4k_&}0~;gKidzwi_Q^@B<|!(TK5x*a9@P5ODeT#I#(6g|YGy z;@JM5zd8}MWoUhg`K(WyFVHfkTk?+Ei#}1vucKI+GH@N4Wgr=D7;6dA5%MPT3zEgzCacgU>^IksXf)rn=0 z=^4EuTp{21b39mx)!7EF|3%B?T5JGXCJZ465`hc!&-(If_%T^mj_li2KpVr2Bm(odLGGYeC^RHsA2OmgXXdT-8&NzP2$;099do%Khq9as-qF!p zzE|L4Jp!HSH`L)`Vx_fIyuEoko)wl)Eev2&n-dAYL1$CuNnsmJdCK&hlnWI_dJ_Dp znCK!_PHv);D|Ck#E59Tsu44FEkkF&ZykP#BKsA%t$E) zyVhP}KI9Ctd3}g^s6ABbp0b8(EDOG~+>h&L^fXQ;{q4<+-2(7t<+tXeZHP&MdN?*& zM(mXswM9Mx>nwZNY)5Jr5}(3o3kwjdF^q?}W!V-KsktSbrue6~Be;fpYxcIl$@Z%^ z$*pihIoO9NCVkVQv9nB^xg}G@u%QpOV_bXPD8d8y$sMYB-uWYDU6q8KYPkpuDeQMs z5B4W1oyRpQ=c0!1LO&QqH0Iu5VFHzH1nQ~u_N=VZG}!DL(iN*qXLSQs4mA8$HeZ9c z%j{t1)v#w-;MfcAz?pRILSlRvSw7km zK5OKYkT96FyZP@YVJ^yu%=vWOX1<-g&jz@S-|tw=V~;M!5YTX0{{H2P=*Cm^7*g~W zJ>JDwPwkWM0L`R;W%F+2uLV*K!Rso zsz3ea$AiAV3Z1oljiCi>k#7fT-*J|ucgJTa*;2Q`q#X*qfpTl=!V5E&%afXba=CRD z{Q6UP+(HUclDJ1{?&IT4ZD)_oN?DSdd|?{BA|KU#eo`e|o>Beb4d>&Fvt+Wf9r#Fu zr@J!J&*EM)8tOF%Lm^IZ|7zPr#9fEFl-AVlESyy44=2Jo)}wVInF^P|<}42er%;2> zYBuzyKwc;fNvKf8Pc#d&p@81*+!p!zmY)qm_^IBbksH!U}G$Jyxa}ULvpKkdA3NU z-1ZujQ3Fh~GcF(m+@~VXk8{B1gzq(k*qr!dj-xV<9_pB=RU=Q2RC|#&Gj_k-e@1eF zW2Iy3xI?JEJ)g=}T1YFc*`aiw52pzun%x3^ucbsSdNYwqT@9oeI_o%!rD`QNMD>UvB zph}?~WISGy_5=h)kjHiL7!AR#&^ZQ2k0;7cp_d|U?8cI;m!BRL$Pe)v*!4`94$Z~$ z@%GKs9FsX&XKMYzXe3@;ce>Ypu1|MS>aP^y;)Xpkr$9U)Ru(!w;l;kl06Wc2dnNa*~e*8TDxrn93wjc19F3FE$I z=q3p0`(vQ%;S#V)x(AUil(6_lmg=@qrOc#HLm-vS?cP}~^B8L$Edegsgmi@82xVmFaEvT5G}ul@2Ii`lMHK(lHgzi1EI9vkqQ z;J1>l-p%*5dM6%gTN2I&ni9#aa)%#f4vB2BIY|OFgSyhx7Dg5;TRKB7+9PuM5)w&? zhl+T?0jUP&1q>`=3{(p1C=^QRlyFL1!WJ-e$$$r_4BE^nrSDglXO0W57-yIpoqxTq zdbgkS-pazP{oEVxH(d*`uTaQuu=1{k?>fVzm%V(ZQN%i>$39G|B7U@#Ht4Aq2N)YF z&pYo^chfyAG<1f9>f4jJtIgKmcBtga(z(?g%!bBP=<9efuFa|+-R=eS@M=9;BsxoL zFOlLvMci;KgTBWk*u}ucN=H(=RNovUdAdM4zOYI%YTLH@?}^9mvQaYH%5)5iim_K* zgxxVlfYEEnd^R^VjCnuUrlef^W2I_GveZkn7~Xp`TN2JxQXkF_@gVJ;Ql*-QkeWuS<2J<(Lwt&wqx|B$MxL8SRVbwWC!1@LCyuXJQSr58A*=B z1(aNb7-c}09w0`Ui}QOH0a?X9Khe2 z6(ObCQ;=D7zDO)=%h@4+xy|+Drs%EMicqWh#bnD3LFR!;`Y^t%lLGS~7jv9mS&P;lznvhD1_{)7 zZ0{|26AfA5DUV)y3jYy}P_L5g#u)lGsr`=_)0;VTyXS~qmf-uYu38q}Y+@u4_1qq` zKmk`l67_oP?y!Sz zCTD6>j>hsUUi4V)OvfvRCkN8h0t}GyZlJKR;qSTa=?w&kKwCS=Aca{w;8VVu3bH&v zkihfGp^UGzHv&jor2=_OL6H`{ab@-~0M3ZcZQ3ly&6ZXaVy>)LDEC%*%^+&x_b@N7 zIxNGUuH2}tUX#+|FvdTCw=o8x6)LgpR=YVBEd?ZK_6XJ@3858oiQ@(9Xr!)soz7Cx z`P`yC@9+GJQrHNx+sBP$sO^uT@b zLuT;#mdEAcz~p2r;J!8K;P9tADkirJuE*{{4Jr@t#dwgJ=ox!ikGirQcxcKh800dY zJ6h7;O&ya1MGUBrG5@kSj+v(9x|+kG#-gKA1^%3kxJ&{Bl_b0DmJ-t|I?+!MGiLh3 zt(ia+8?LOb4`}X35Q*z#WUm_o71c@9zQmDJh(xD#$)D9Wayh(r+{$CbTy6`8<7-UR z+r1xSP#T`oT3Nz)IB;BJB?83lHJypsoNm09#A?&ch#RMt4WC^}GC8_Ke`2Zg+J2MX z+lnihP3H(6V#-^zHv^t^)kj;)s3tw00-kljzzrR)HZC!D7j~Vs)D#PekYP7H6E>;hp6)*clslHYW zr6mz@g5&`_q*5UPozjl`p3&X_)Wz^*^;9E|yJUYfA*gaK+7f7BP&Wie0%jJXSrcQw zgN*}lb(}OICz0?{dbp&&#;AdU$$ffebQmqJ1DMbzAzXT~&U>$H9E zC%xP*9(&W6weP6EkDwuDpaLi#BzWVEzG!__?S`K)x~o7cFez-RJz9u~Z)YJ}1gUHg zEH8VDacKQ&p;U+A{T5}=ex#*Tc)290wdbmHF(`xO_}D#+Od}12408H3C@)+Lb%ld@QZ@f8Z_nUw9*X zAxmIST@T@5gKd0T&=hI0wyK1l$kZA=MglzJy1YL=R|L=aJL#60UBF=KL83&(WRe$h zOPu#X=)t02)QT?#;$uN8GO;raR9)fGk zVNyG4jV7@*q}p&?n8Wr{@FCh@JnxLM9al~SG^5njP9|s6DzZ^vo|O2f&{3b%eAiSP zosN;>6iwFDp0Z~!MO^sQa%ng$IvXdQ;NP+k56IW5`?8a#r=oEfzY5vz*HLR~A8#;~ znYt?Gg!S{&r;G7)=q*h{91b872eLck1FyKjGc4|*7E%#X?f4wDhRI*?Dk?zm^gmU@ ztA8^Z+A=Z|1H!V@zgz{E`H?t4hJ}!iISvoQPfSi%fn&gf1aHwbF*%>2Oa>o+CEWwE zQ@q)5JfYdutcto0o%{Q9lHqJ?@k4Fii`F5ND5>2jz8E7SysG+2p|mPsP0?;B9Rswp zf~adDIjSL9nWhpoI(<>+FYhp}*d7h-Eg{5=N-98|*XT&gs%y z+V7F|wgY-QtxbIggTG7z$ecYhJ=xt_1{pJG`=Jh{#2d4QXXk=0_szb5d8o2rNR)B) zv!Lyt5nYtc^K!w4EcJk=QaiX>BBnc3C28L~>eZ&VK^0C$?H;Kk zkXYhEsklDuWplg!8CjJtPqkc^x(1kxrnDQmA5Y&ds(oDeeKrdQw_K#;!J}It4%)tQ zp9#@als?U#Ka4f4Ukl(j5L*JDG+dvyU@|QQn-YzVeM4pR6Wp3n#elLz`NY zaAuG}R>nI5{;mIY?t=lL8I$BA!c<=o#g(e2VDK>^oqoAz(ap`reGEeWGX`4@b3AQ5 zjVM6LRCP<|P`*n}XC@!3PH2Aeoj9!fT+uy1*-f1E(o0Tdh+uTgqH@LdS#y7*p5CHC z-j5?LW@D5~srcNn3R4yAT!H~*@?Z?Qapq0XxKOv}{}Gd+@O;vH2KjLMX-?&1j_0^w zwn{W6vr2IiZkU?XPDwP!x?%0mwYIgDUdhNiyJZu{Rq z1kLscoe{pi0-CaY0)duhcZMDPHmhm?D2(aQ(js@NeXB*#S$NB9dma8QYXvlTqJT%3 zP|&mpk-P_*L)tY45| z?8f&`UYa-b;4gQu^B`U07+;no@_IJ?z123EsH?*ft(Ol*cO|E-LpdUk%_gP{=XN4B zr3v!5f_pSNiF8_PtjT+6>0qDl2E299zQ0TZ;h(=-qOmjwVNI~CJl<-9e$&$Z*~=)m zgRm_1BM^faFHE4m+b^p+OB4Q^2PYH)163=yQ zG$M4hbonqcQyxgSLVx+|EX~N=>5Tjm5$|CIQ*#O*1-?_5onQ#QQ%~F%hc^^=ep(S% zq~;957?p0y^pBws;ulPnoR{RE2H>noN%!m)H4l4~HLSe3R%?yk{xEOD+~6QmtyD5( zMoLJ-KrZ0*>;kZWo>bLULyNV`TKi}w%uJ}@eN=Z@y(yVYXKqQ)Y1Vlgaf>9xMRuD~ z7Rhu;<|S6i3tXE-crNZ9)6BE^=Uu70gre`_+=ia_-RItm&)&VCP$q$9Y&)%4+j^J6 zpE^#>!)FG8wwgNqkhyDSMC+z~2$-#U?e=2hCekRrievwB%XPbsfft(tzSc_nb^&kF zOKs;N!)wbnitSFnKhz|=ePjf6)$}g!0Qu*q79JHqH(P-@F|>HFD6oal*JvuosArhi zh7E2_Z;8M57U-2f^fEh^5JI2=C}(c!Z?>w`xHuohEE0@4x-Lm%41!7B<4&bbuD_(~=> zo2khOl$3|vBuL*RmQ;lBQ30g%<=Bo~qYMhs-;8HhrhgZPMW@Yjb3yVosMh<`%mubr zdd>70FK=6zAwxj02>J3?Q|FWq9S>@~_(pR!#{>sdEVF-$-BGt^;B|H;jWQlT$(&Yy z#=4--H?V*Cd}OyR%ZY9KB0z`4BN~tTcoR|Z+ePKWGpSqIvaqc?G)`vf4AXF9*cb_s zodu2_Le*lpv`UZs_rEMOp0tR_LD|Wv;Y_huY*OtB{@=X|feaMX%*-~qovRR9ubV6v z>;g|u#+dW1Io3V`1$mYXw*G(*_eQ(bU@RWW)Q!sEmM*w`0Ks3syn; ze}S6a`c7D1w-!}Q4sl?>O^Gv&j7PpFh--k-KScYyeOCXBlRkVw)j9#m=Fv@rUP zQJt4_S(nk{jJAScwTB1UqpGBk3{Sty3#M)7RW+s>8n_tyzXbXm+qp`j3%>ReScd}P1tWsx-j-tDwwyKcdZ|C_B6xS zYU}9Yq$^`ek(ISY^_0R`3xDCnizn>UxlZ0qCoPJp!$7JP0 z>UG*rzU)g(Mcyo=O=h0DqT+udXC>8H4c}7Krvai8V@cttl!2eIo(`+);pY10!_&0u zlg`N$CQz|~NR;ctaxq~|wboTgWf9mT}Qyk_E^QscPCI}}hbBL2Md_qxF z?G+itrmup_Pos%5P{oc4_KC1*ZQy4=FUdpnF@hqJkaq{tu%nl!EQ$Ev?|`j+{%PEq zBP2imNf$4@nG<6f&&Ves!o@FXCOJ!tkB84fogrCtN*hEdYR?}r8%b7?HpZddmnq}o zV_&TD-)SXN@-RAjDI)h8!PVKGQ`2kGx@~engTsx`XjZyh>`O@QjMYWII4TL6v z(Tn3eoUQh{8MZKX?!HH{>cx1C;i!}RbF9sfe#VL!VGNvwk>))^S8#Le&4Q#piduYPcYJ4}^m!u?l4bgFa44qm5IM88`RAmu9(!&m!ydVI52n~# zhQ_*47nr@V^%O(1|4FK#E~h_*cK!P^*LMb29JhWz14g>?3yo}=G?FY>Xhs~KJ+KKg z=HHG$Z=K6_%9jgBHU05I@^ujS-R(aGe+vG_(k{bg**+!P$UVzPCiYTO;o zm~KPzBUi#x`h3bTsBJDULe(M(@-(memHb*0FjNO^53NEinH#d+8aY7gk~b`lW~LGO zrAi}L$KaAGfHXaE*awV(oPhMIwQ_5V-#V_>9r6=+8xk{lyK$x5<>kZL{EY*1;e*(U zD{v+kub%=rP%eSgGk5FZ=;x4#u5$A6rwR;Jjs7mOk`V*y9ifYHN3arDpa_OvPEky( zuo{e-GzYCiHjskhy)S9veenM6UD)Xv%wG7s-)U-%x5_GbMS1LfEZGPiYZg)d7oR%A z)t~k1JC7KGC^Z3i!vrY5(Upxy04O?;!Gr5SVZzHWc-uc1N{ro@lHL3c`g6!oo$A?r zwk5z=fS%KnCCiji1G6SRf8HA26$G?17@h*UzEBZ6)lFu+u2muxnN zNN9G9g%AykDFY8~n`Szn$tf;?u@C!HRFjH?8wE7&g`gZa)jZD9#oUmtz8udYrinhLJe$rf6>l;O|Q4DcES% zwQgo_11{PmX@L8buyiK8_Smyx;9CHshlfXCm^OBBNNTYJ7b!B4T*l#$P&s9!r|4+2 zcgeg(qLvdb`aIM3Ikps3k^|+0n*=W?*g!5pYR<#bhMcY*$cS~7p)Cak!iYhP37aFd z+?_A3tzn!bg$89t9DrhjOsHRqfJBZv84)#X^kE1Y7X1X1bI-Kt6XS46e(R_XIO_oE zKSz66Ypr0dr47d(b#L-!v)18v6||y^HNe*rC+0Q`Q8T5J>myh+|Eyv7E4DTiND7h(VuQ5yulrZ?lX+*}YNN zt~XF}Eq&}G52c!W&j-jmvzF$8cWT|*@$B;Cx~!~Xt%(v~qXB3OEGfy&2Ou500A8o$ zZ*^#3N7RZ(On@ZA!pP?E@X+!?q#sF((iM!KSN}*lmL~ijhN-x%#4$1pKly$P^J#I!8sWz#&a%0EiZ0NK^i7OC+f$JsSLshgdHLNUV zA|vPu_l8v3aPBk!L(j6RKS}=dz$$FFqV%NeiL<&=UUIyV6yY&$u`4F7@}=@FDL0nK z{I8Hr5-}dSTX-fpb!@aP1vUXeA5w;m=~gSF6oL5J5IuA*;SBSXb2y$jz&Dc&U2AT2 z%{RjEZeby|I*GdA?i(Oz(c&E3bR_oPVCmT z3;DIO01$L-;qinhV_9<6MiCVsYp6k(6T2Cmn>D+C=t{)(0fx31I`!cVXTn|_C;`jW z35>?A7!R09`hcd(-->}%r9Y+9#JWqZ)*LX@;uy;4aduJV4La2Sx2Y9PiUk*CR2dXC zlS)jd*t^KHeR{>2j96G1)FHcT8|LVJJ&KH3>gLH3cXrrd*iRsvTeW225B9uaeDov< z(<)axD4*Sq*T<TVR}c)XmKq&P|cq3c5Y;IvYeT*n~j#mz|AX&4>+e`}{e1WFy9XvOF*K4gC zF^MFzvRPo?4U=(syF+QWwIi1Z!)?xm_)CGlsc;UP3Ti0H$ffL<1R3!B1nYJr=$mN} zftp4Lk?@hU0Q=C`^azT+N0^W1IngHqP!^91^6{}W`fNGhmm!tcmvx#EI2a!2INy+s z(KQvrPZagY3NcBM#K^-RO;gZ;VHvRKdKaMAwd)h1(d0){$#^Dxb$>n#$1^MqK8YR{ zIce&*{!#`+jZzgRWba!UDx(RQvE*)~iYTr}k12tu`zn^p!Gw@$1{jeL|C5&bU9@_0 zt++=xcNsEx??)%=dvk0|=i&M*GOp>WG|jZjD$Gia{D;$qB+5akX#h?lh(`#`*62T- z|KoHNl;e1ILc^k=UilBFU;I^g#3&iwSShLxiu0rX?mz+Nu*8_DB1eaMhgj7&ajhZN zWubdr!BKF?x<%@iNm1&k#d#ks`Ph4Ic|E#OBHx>2NR(d8im(o4=CRRYqXC-?ZpO+A!Y{KIDE1eh9rX>P>~=$8tR}D)4y=juHxG|@ zsy_V&Awy1x1;10z@o2U7hE| zXjK?qP9#m+nEUrtHR=omO&IP;#YtG7+WXEOr`XPV}Rfli~}|k`r9{m#8$!wU>)z{N`&uRX&g()?5TeBx>+f zkMv{jhLrcUBvkvQnl`KY!|6cW7mwUDFpRj+x0QV4IPs%{dOwdRCN1)@Q$ zxvTm1lQYSTdjsY$B4IlSl)B_%dR8|N2Q}AUbEZ+)L9A?gdlS;}E|Yn#_e@Oy{Fc*%43~1UJ(w4(5Q-6NUquo6izdG0vY-VK zOT-|+;5S>6NQ*v=;870*`CBIWWrf~KzbDCaOEH4wI7OQfe(q00tYzyUjM$rg)(H}g zC6-L^P&2cZu@IKxr|vM_xzpDs-xhn#QB6$D(Nl|zVb0Dg81y16`CE{)Ozc=;Vr9ok zywd2P!?ia5&px~BV-@osG1yR;OIqDDjp_7()rd{y0vz9*JWmfYSdh8x5ukDsf;vzm z>Ur=v;ir>{5xRQH76-WGljZflH}o;{QRu~#I0`G2MNB8m8`!}yq84G1$@VO)z!_(y zZVK*M8QB^zvM<{5Ko0K(*(&}KeLh_e!YX!{z7A1PcdV?KJX8onyY`8-2L?Alt?yu@G9B=KF1!A0SvqiWo06yj`>*p#Wb5n?llf5*zeDF2 zA4!j$!Rq`qYPvEaK$C&ku0SEq5lSGiB}cdlF}<7qm0U{yAn0UE7Pi~nT=G8Tz{l2I zU(rNAe2RC@X|;fgW_?}&bHA86a%a71zVsTM22(ixQk{ljR<#<-eyp<+Y3&T3&r#Y? z7ZN}G53)HbA`)3`ykJG2YJ+?UN(lPQ(}efc7pw#Oml9S})*tm4)zt933UP4qli?-5 zs$m9Q8VP)iJJZs*c;aZyrXo^-f`p2i|NNYR`zB0rt67k$jqjhh?DW1*HIzsz?QILs zwH{0h|BZ2Z5m)1eVqx4gB_5lC)|N@f!_KPaO3Q62G&G&w!y%yDxLN6NfN~M z3-$OLpg6CDz#I)@=`pk^4`cB$mnr>Lg>gbScwCT?f;Q&>sL*H)@L9I3nQt(#WRb4Z zTHvf_!2kJKL3;%&4?$f$Rn46a6xq==XhTOmb;n$|F;tW>co^|FBomu8aN17SC0v)= zM2}lgaD4nS6H}nD+&>Ezqn0JWdwPXr+w5i~Q)`P0caf=hPKAnAbE_o%g| zb{9gw#J5ET&=ud$D&ob*&qegkbDv%ISCD~gR|VKV=qa`j%QfYnR*FsKCr zs&HCEV`ZGSIB07fJre=#xZd!EJE@N!w5q&SS!IzzbQS?E&_@|{fzgScR2G2ubf%AouUT!b#m z#s~xO{paVlX_=foMLQ9zRYE8Yx%qf)YqGDa)*UeE&sc<~E4s-obQN2;b-Z@bA3wvf zo}ORdUV!kE^x~dt(7OjU*r#jR@ij1txrdOdn7Cq;AmpXZ8bj%Jf82-A<;?@Z_pT@bmgma}s>Aar%gnsquxcyUB_scd+2>^xzh>tyJ*=9Hd*{9? zE_iRLiF8)JL}rs!zNFfLXJuk?AYs;!UBweh=8aAa%R%M!%`{0p`^6JI_`xbo+bUC6 z{fRvC;>PmypPykNbl%R$erYBLihK$$HMEw3K=km3RRsu*pGpFs5tUTB7a(WBwe6gS z@0IuhqiToTE;0G3LUA;yDZQD)lDJBco5{M_vi$gY;`$IHJH(XQ(2YmIiUzrRx;=`a zcqHu~axxOQ)kV(k{E{Ai~M&C+gsoq>PB6BZ6V4 z3E3_d?ci;q^QHfFr^DUKOvOP^5x3Mi+ISM;@i-NSh+xj|h(d+k?^nZ%BBI;^63gu| zhhJ>o6ZS;FkUp{94yeb=Vo1|1f?qv9LY{j`xvho7!9pFI#%re(tskfpQVXTUZ$&_| z)P6uamjIddUn}iey2)D2=_haW;^snDGFoKGsKWM;rKe5ZKd#)z>&aggUu zN|yJjGBL_bPbVVAj#nQ4I&!fq3xzc-#ONs5l~fjaaFHpe&_h)7P4UG5 z6?u8SFkR6y!a6V|`%JlNNYt}XpZ%Yd>h3VNM*YvvdVVq+ z;y-?FQC2SBr6hq-YvVMPujRQ}=0dgeeU=!trf?kl@iSUd2Yz|%JHJkjlCKsm^Lg?A z`Pt4{MgjPx_9DrC3uI$n*GQ-NKrE9vwwV$;#=`x|)1!%hzkcw53lcy&yp30W= zSY9k8V!)IH{;}NxeMc4O-Bj!wt1||I?W{D^=U=-U5?*o+c1=9-pbCw-O?|-zTYhPh zFsvS4dJv$buRGi7u4Z{xPZUhhbTh1XR!u8!Y4EM>X-@84Ij23gn`F|VKv#oPngQ!7 zOy$EYD)^F zanpp007H)r4_od_h7B(fG_cBcHs-8hoT|BV>_~sv=<6Cb+VWd|Fd0Hg0~X1XC*8Y* z^VXfenk5mXBz~{IBO6Cy?9Xv{IT=!fY7vy$(D8ZvW+l7lxK#1&EeoN8JcSL8!MQ&(El9Tug*GOt(TgLaQWxLw;$2I^%DeCQ0;UgO-(`b}^sX zy=J$u)tT;=28Zp|2ubT!u3kZ*#DQT|0lcK5g!*F3S+L{eM*GF4_&IdU$?C5<84tvu z17x0(ETt$amUU*0EK2)SfagLWswqe%wkhkVHu=`)yj(JS`EN)L5x)3WT~7$Gwyg0E*?E7nx4Vccv`Gyx z%-5|p&;04(ULAM5_S+3PnB4EAi0)>nClob2<@k!v<+Lx=pV@wyElWpXdq8D$CCD~o z20>v+ix0*0F(by!$T?gDb7kIpEM1t@gi==dgb_}@zuRT79ma3&;;>}HbN?SQ;^AG0$q80!^abCnO7Tx*Fd7QZNx|%EPWca93*}>O_)qd{~%=K`s3%qX0rDo$^ZFT?*HfKsKwM#M{=9yGw;zUGC;BS z>VNmoP7*M8)pp{l+z>za&+BW#g8$t=kBEvzP#=$jGh$rFp9K?wIrlKYnN%Bxs+tN!dFUa4~2+^M%q4J zdZ>O9(LppWQWO&4`eKeLbq5Te&_JU%(Q+QFiV>LNY~QyjXQ59H3bx_e7evUA-sIDm z;tQKKk@YWru2m}aCv@sJFwne6(e8gpP z{1kmoj+xF4@}x5XY9B$T^J}2&SZMd`5LFm!r8TTo$;06e4!2gfX4D%) zb4ns!VPK+UIM|68A3VMKx+SkVNe>8BH1J~Sm$BK<<`fI+9T80fx0DTWi>?~YmI|;4 zS*^BK=_*?ticRK!WHp(cPO~j|6m(f+Tc@`IbKjqPTz+4%k28DfXS`}#M(=Ns%74Ck=Z zc-oEa-YrQu+qeietE6@Kx0g2BYV}fz!wjKh2fyMmqYP%|%&a|(irqvNwMQGyAz;RH zX2w@ar6R8!yTD`w96`5AUc!Cn*@zomoKk$+@tlzCcX(gij3i^Y9&6K5?B$7RJ5Vj0 ztI8!NjOi-FvZm-5TbkF`bucn6;v~6CyZ8*X2Z5@|!dP`ylRA%)KhI1MT)}k)2xqF< z{@S`OQhj$Gyd{FW+e`=)RCvWQwLDn4q}Hk%j)PHfXDt;C^s2ttoOX>h6>xhZcOH)w zA;(g%;f;y$p^p5_zyH;c_||lwEHI!$N^|C-w@{Cha!<#`E=Vv^Sxl-dl+7}{O9+m9 zy(*XSW7R=RF@OpyEUYw0V~x&wr5aH3NnywS$TX$U?Z%v1_l+(+HlZ2ixoAtBj@`n% z+|pHT<}ct!b?qn+t_x9v(1e-kxV;sehvq2kaVZo?j2>x!?r+#82^80;&DhOx@V3|G zPoa1#u-!`nDWXOA>y zaG;F^Az#I6@+r0hcfk=<+ikil2EaZAnKn9s}^hQ7b(=T4HL#LZbd#Fq9 z2!oLcPj|a^?3)Q}PUpsumD{tVgF@%ro5Kofqk~h1Q>_`rS4ZLQdv~HvH?VJCOVHS1 zDTD7bG5gosP{UmhEhl?`^~b>j#~t-j_%WEtxCAYJYp!XB@tb{CvQ(6joK1``{*Hq*`Iy{Ud^7zDGI63FQ=V`$0W&G0XlD z=H9@i5jHc99Sh{N4Sle)HuJ8&x-*3KBB6oMk{n?-EYjedMxfdubZ}jA#?&(FOzGrs zQ_T;0?NhbUiU4^W=edZu-Sf8j_REccGSH}PD$`VnZq7GjfByoz;TvgVvRp!AtT7Zt z85kT^%RyY-zXJnDe?ttXLN}B;L#Sv567{kWd*}vX{Us_?zzBY>0k}y)n)7Ah|1ad3(Y6ZuO&bjn)2VVK{haOGzb8QS; z{3!%r!$JIAOVp+BPkmP4t9-cC!@##8AU4W5}933O2K0cvg zNz3vF5@Z)&pNm27GLy|d&ISdhG$k&#Wpe|X4?bB=2HYW1o;z+tIn4uDX5=# zu;lQQpmE!^9Ep8z)<_R@3Ribp_VwL){`;Mu!DK>Z-;%=tg%$NlotLo~@YL zSQ27%+$3qy8ikPNy(tKIwgC_1@v@96z%Ms|m-+=&rYZEe>z2K(>KjEHF+K@>@IRp+%ICa<;cANHAo-k20|;P z#@@ps^3l*%i?Im+0Njuf0fAT+{c%ytV=NYqZ*>(!LvBBbBp$gyttFeC_bTHDY$56Z zbk8eQBASjpZakX@CAlmCNVj`grgt!)L3WjYr0zX1*0cO5ui&azyIAqQ&@a^3l?DXz zDkXsdgfeS79y4aqsNEiT<9r>x>@1btmBxvUN8kmc^F*bjre2^fBl8!uI-q1 zQ?p*W3G;f$36kEg8M14)A~3ckA$N1Z3>lvX!l#3FD}NXgph9k z`N_yL_+vRmN`%ki{1~#d@DPaR_{{JTb)4zB4oVP_@&aod!lTDW=J1s*f?Nyw4& z>OXT6l1mbHX=S-o;s|RuC3k$~x!XRNX#MM9tILW!o*m2H3ME_1v09;t36M7a=wixY zErK{FI@Y}mTWxmQZJ9H#Eb|+)q^dkW*}C!MkW`3;b4{YW^rC7m41=Nt8FdF9oh)57+X`sn7IA=?3@;_OM003TcVsW58iIX%qAMp zV!(pUpik7FvYApLWtley|KtOAJoaz-PeDp~@SbwTK00X@nNL-aCA({3<8oKec#@ne zfoASzJ={(@nXvZfZ@lqTEAW3V=9aKi>m>4X1*UStyPonP`sW{ngQOOq6GQJ@O{-a&5Sx6GG8|M z-Hv6I{ig#qut~BNBwq364L2Mpw>IJ}#{?qg6w_F=A!U8q;=NeHKR^1Zw{d53J)ymV zq!ftMhW^^X(2@3t%3YS$f3ybQ-Q9_DbZ|$bs~=ts14V=bBI6K30b+o4x(56snh0cdO^G08Tw$WOTKMWjob~I^#O&S}``w$S@^mY;X%mVEb>yn%s(#pC!fUaG zPisuKc(6t;Se|istQL(k#^ZcZX?s+*V)`lbcE&BY*FeG#4Cl7Dn}feV+4-LTKW{nc z#)F>X#me@(+Gj(Q05OD;lLbrsCInsYkKbNjyOq7Xc-XaCLTgv1!}RE?^9shO zIgdD`U>^UFGqy=~2Q+M2gUbj6B4oYnhclbv9boc_n-Iv#M?1fA~(bI-O7>g+kLfiexc4)-Y z+E#7L5?8%$T~Yt5`o6jEX#>`+^DbY0rCmB(^C^{4OM-}9KUndU`BK?ehVQ%dH84?J zby6EY$a6~>7i6F@AS8GD(l8XD)zv!R=XnV=p$-q`AqIKJtop%=UmPi3eyV<$QcpTb zr4qe|ky!7_O+8Pbk-+H?KZY+rF|j_0aESdcb$=vRn8d}`DF&=gBM8izTS&x_G4kze zb%#s(Q}x~J>BPhaPEy{phMiJD>Y%3gZF*hTXZ>__2+q$9>+~T61Zbx7Vt9}yP)dkW zGKapCznw5!?kHP<{UMNO1X+5jBtyoZ$cP%bkztKuVQdD4zvbW=2osva}Iq>!zZc>hpst zo}ysx3wXD|9GfD#RS;a4cDfVu5qwO%VV|dP+V<&%VWhfZ^tUy)-e$GH& z9)7@4fHo$76E?koRzi)+?iE=3xazn4iIqi&gQz8x$?NbU*gN#gT!(fKxL?^AjLws5 zeKy0Ke)Y}lvY_g;IZ4J&m{fix3qr4xYMuD(j{MX@KE4uo>5`be6*Y@4q?*8W(4>Wg z5H%TmCM}G%1Nu}7mUL8RE5E&Me{)xyh%JQ;w)}FU4jl8 z8r>MT5O=-|y9s3)T-~<;IFlY*(gB6q76yeAIMfyGd2H*^blUyN@+cO$|d?H8*6 z&u7iz!0yesJGsWzzNn;76RWD8rCuH+a+|sVq)H*kh;3?ZjluJ&?s=f?-WlG7WzN#CWg4A3caImyKHX>VWWcbW_f*ckS1Vz!&j^#YJR>L&hlfbxRubBj{)P+WgFxhb~IM z{$K;6P?n{a^ySt!r;tNwW<^Drn1!P?6h#rVjGnQFXOCEZzVEG+Z8-$J?RLk@n|1;! z&VB2ti_9fBIStD=#4}8M_r@tHJPtC#P|U~f&&q4IyZ`n_pjp7u5b+|b>Yo?@d@e`K zz>0PP@`%-o83e={%Q2@Vz%(!+Zz`<(*G{4)K%yIC0zaT!ZRTjoqp-iI&YKxTsa58< zFdP~&Qk<9>nVtOAuqPBCCW+EI7aGr(14vHta_-1s8=q@HukO)`;fVyGR0~pWf(}d& zJ@QEegv~{SDiK-V0m-4h*$d->7|`zT#&M|7pu+rlRp<`;QJjH(5v^kdW#nj1;3mL92to z3O!?TA-PO|MImwKk)Xg-UQdjf{jsjeEY)d`nz8Ue&f# zB!y9UU=#|7opT&WRd(8@aVBUpd^s|*XuC`Sj@XIs!O`&vXM6))8AhpRWB5Q=?0877 zc+FMspLhs3yV4>}e(AnU7}Uv^F`->cKFBa2CQ|bF*W;gfm{01t-(8*`0gm&La1%b6 z2Fx7(s_`~F3(DY5K()!X;pmE=nb-Q*m4pJ;1>|uy`M-=2#Fu+upc;~U*QCg3wg9>h zLAJ(m5I#($@2I}+mj>B3|Wx;;s<1gtKn=NWT~o`O{FGnzzaT?b05{VcfhHwSbt z#z7ZicrD=hXdr_`eZ)OSC1s9jGpB!_z61ZZIERJN(L8h<93YJoW*VoVb)Lkss)FE*f{Ci}(|gwWUUqwjtg;k|P~cvDNz zT3%lGTR~PgME8?>e<9}P%$m@gmd7n>@G6U6Qc~i;&dd|8dLGz156HFmjf{%}2MDFE zjW%H~QD&TA7FT_iN6NvsZBinZeo#{EoELaF5*u}Du`V&K{NA+?*|;p%w{Rn7cmrhF zvamauI%_@UyEn@6iFBE-m+|{!7l;4x( zrWOionh|=iZog&3OU9%RtIx_rOM!*WiY+3{dXD@J0O`bxP9z){juSO}=&?E-Ma_D+ z>N$Nsdgi^3vr8|l#U5+ZxUjq-iN=gP(Cq6oFjQ-+7&v`iaaWFZ#X5+#z`H5k>}HQO z3z`sR`1$tpf2+3on3^#whn60y7jkhauGl%|v!~vIYancsxx* z*wZ4bgSxDe3I1KhH&wef09a4u1H5W8wX*3#SHoZ%9mBK7zPW_f>HMrbltIhaeKU|n zz)c~3v~XZb2PlmJ*XSW7)AHCj6K$iT;&F+G z(oa$WV#Dme({YhRvCz0iPE;dND6b7l`XW{j&Mm+`;eZ|e{r;Wfw80voukY_{3!q$EI;S{VjD3Q?cu88)yVr*kyyLt;1dX0W6bj zK|2=kghac2p*h$M$@96M&w@Q}qk>F9+mwuGmW&ECKHXC1lO6qOT7c;BePH=x zPK4GFL*EJv+p$_e@Tq@N9#k|5<`6=hm^}u=hC{< zqy6Dd!k$ZCweyK6%F%~!GN3|fY$b1ZJ02uRPhE{}*WdH01-(r!4R!5#+<*+93(E-^ zJsi}zDt4R80EU)F1-PXQH?jvE%^Z9MyM?JM%3Ku0iKdN({DDDz!+BN7#%bH3g`>@r)yh`li5!GvBB6N${@o%sIE*;VRtL&j@+-cf`cJ} z<|uMWwOY-z_N_Se7)vU$MieXa{GTfoq51wD*oLoNsGN``Xw?dbRAh35>#_1#7mln{ zA!<#i+cQJRvQE(*kT6{9>-Ym#fuwZ*_{=GCu-``@z5(q&7>94gBQ^ZL8u5sC!}j0S&vAUXlY$JsE<0pz-F{1&n~BK?&X|dr8YBb9gdN0$?c!$%+=+=y zCNxOkONv}{t;55uV7=J&oO^xx`kDKD>Nbrbz#?ZuWo0`k?`X&wy9NPVv%~`-Q}gBD zH&JBRyaZ_`b0NrB)An=&3{{dOBKq^#+Eu;=+y+!;8$wTv7rITYvuztw^^aco8^w(X z36uJP;_)*c#;z(5zQdwO3AP&xH6s&pO2mtD16us z?WG14sU?m1B}r+=pkfyU-?_MA#fZzqgs6iTFN>&RJ! zzWDkx4~kx%r06kaDUdy%T8pA2KxsU70rR^o{G20kSnY($S9~^9>6A-y%3x-tvgaSV zeL!H#B@;Aah zksm;dBE}ivyCLha`1ts?qv&lTJ#3Npvz*tLLk9FRW!19Wg9 zc@M4@mkGa#&*wb$B=Wt)>rb(24-~vazMF(nZ`Z6)4YTeERD=1>YsbeE^*? zlpRtl3(o8MOG^(EhxD66{0vIz8bbrNB#A=YckJF*G%ZRfcK!o4Ht8^y6Q7;=`o3r7 zSOYbe$CHd{zmFro-O}cBTY_lb8MU!JuzMpl3j9z-rp(c{!&QFayYv?Ww`O9f(q0^7Nw5;#JWvsM(DX8zz?v;QB4q z^U6!&0pJv9bMI>W`{a@{UA`cOkRV?>`&j@g#TkPu69tFbi{vJz9FBsr@>ty*wyI4O zwm8)t*pK@A*fe1sl1jcP^gXyCDLX#A~Ln`EShTtFmm6w$xd>OW&ou)B5F2-I>q7PgrsaW(^;gOwf8>(aNkBkyC zaORKDlTHz98ZVqG13NbO?A?Qws0|I#19CM|YC^r~d7{#V&q)628ZFS>@QW}y{&#TB za1*2XZdIhoxVW^@CPP}pkTXu(PI0qMjU10cCH;%G$QesY@=zeD9J~o}uMpkYP5r44 zt+Yy-!7ATo9n3pq!I&eLaCTc+i3nT;`|lUxnA?K`ME!xLO{e~qVo3{0>G<}VrE&tB zC7V~P9hT`0W^ybNpb0JE%-td$n9a6nhYWj4#6$*EIUsR=`~y)tpSK%M4&AExPv07M zM<=AW700=*BFILZ%Bu|&ANT}>%-#o$*|?6;qXZXCkTR0+jh6rRE0O?BZU3b#*ryfa zpD1P&k&0+3a%VqEUEE}v7UNNMTqCHh@2tVYWmpyUAtgAxPhChlBj%V&nNB0|J|RB7_(KWg>Pm` zvq9Q#mRnDCvtdbZ>tJCP;C5`GskQ_ONML3A7ohSZ-k<{xJ7h*#9>;++So*dIL(LCm zBQ(Szgxbln2B6ySoy_7A*vY!_I@$hWbv&q8T=(C;L+&hlZHMlN7~(5MAh_8qL>+>f z-9zQc^@(UZ)7x4|k)d|B@P7fODRB`sDAlO<#+*6esQXdfi0=;~J(x3@xsJRQIb>QQ zN7bD#vxN8WLR`cE0nBleC6xSN>=5gMm>38K9P|%!$LJcO=kiZC<{|^jL7Q6$>xvz^ zZKh_T>N1aX>@4!Vq0wTI(Xhd?JOumZC@u0R8MV^)YnW!cfIw!579Avk7D*Kk1Zx0` zV7asHHxS>#L$7Kxp``1zFC=;0$IDQsCC8A2@z{q)oVj`#Ys)pe;hj(L(NOs>W5N?`!+w7LO0VEoS5IFFr81v+t`=OfwXvy~?#) zu3EvdGNz6>O@k|Mh0#9RFSKo=pO3KhNhtlQ&$8quN5dlfx5L{SBjxDRyx!t>@n+k~d02X`_~}K5r5vfQfvcZ%VDLO{9L<;@xePzc0qf;z zVwlLV2yG$N)=?V`j>J3~I2oQpe>zB?AwY8m6;(t&O4d4W*@#=S00?wE&0$!JOa(dC zjpPFW#k?%egA}IAkJ!&yalTK~go{s3QxGjVFJX9b-%uW| z1Jy=q4N8umnG=_NulP@6p;7Lmg!qYzpOyN!r;m@FXmUoDqdLG3BQ zCNpm?f_Lu`rCC~jn!wT(e?vft8-*R=Wz7(~WqH;`nC$s1Ltl3ehro1)i;ZEyh(kc2 zqktZ0(LVlKmQwr6+AGyzkS#e}2aX#Wd37DV_t#-aNiemb;TQASf%PGw3>xlC0yataL2 zE@1Cj1FqUIr)%mkfS)pD2XhlH8*{C`{!wDnvwL{1RiC8`BN&%nlE>La6ryC-9>_#; zatO)dB3(vNN?As8N`*?AVtNXmirRLB@e27H6Cl5BNXG0wGC7d=tZ6SBJ8pcK;jIXmWIq$YA0)vWHGfg z$sm)Rlh#Mc`>DrGBH$Te4v+^xtBP_5&ZSUkIkpF&6|O!e{2De^_XIB%Ek0vl!ITr6 z)Ga={Pe(M5n17s=6&HagWYL1gtX@E4#w>1Om@u_A1qDLRNX4+tnpggBxDFopm*G+x zIC}JKoWX#2PoVIRFM%_bRo$|p)xCcpCTJ^C##yUU)+i@9%Qz&pdI3^U7ZEZqnjj=9 z=)y1}+L8m2J8~b`?|cv2utb9BiXCXlfN>Al)T)c|Ck3psty2`uq$WLftE*)+^uZEm zFfr1l9-;+&Ge&3TX_mh7Q({lp!v5)1d*TvyrNKW&q zs6}8%XxW2FhtwK=jW8MV8T$d75{0JVYnThk_=r_j0R*Bjf%z|m_UNV(J2d+5@RJjaw3@)6qU)Et`|p$YEVVT zp>H)yvu&s&L_>pO^9xFFl#^c^U%lkzSZ=h(98Z-kpAqO0ep|1sC@1{^>m`sHgl_FNbf;icZ}& zOg57X>i~k(-2?o=J5z#z!Db)PYRT=(C16`4IdB=848eb=pS>ZEFP$ zkHgXPSPd#Xd^Y^qCcdHV8-wsbB$}v-Z#ieBd{KE}{N9|>aFA`AVhuBSRvAlQeq-Fz zsyDoS>Qq2Eici9Sa8yF!=UvkkcV(clpI6s9Z+lqj`Ac`X^e?FjHwyjxn#$Goyp$59 z_0SS(?M`KEJ1B|(bj6rA2*_kdU4Zv0wy8$-=8mS<0+NP+T>HVCt zhG=QW%U6$(b8kp|=z!Dlfm!8wLTZ(^%IK5#)C9fFC3i59d1Su z%gOJj_|6ZT{NjzL>P>WZc>#f4%Jh_H=Yk^0(6-rMXyO}|6pZ)XBQFE45=JhoScKL| zSA)b<9%mnwm@Zed&?P;{%+vT^`vcLKOA_1TnQEWo2x<8}_de4iYOgc6aU*ZB-P}0+ zl%I3UT$g^j*1W{I87zEg!y|7Yx+Kn*Qy>Pd%ktl%URYdcOvZNjGwJT8aVksh4S-1# z=aqZ7e^C^^N(RDbRw=61rb^0H59N06FgXyR1N7pJSGH> zTyIc60O6*sZ zEI@zaqV>v;d!7WdnxfkcI?oxkzh2SZP*f?XqWqGY~A&v<0MGL5L9D>Sh{cGTEvlcxQGZr!j zNa$(wqOH1N%p^IIUt$k?kr1P57na;>Q7Lfs; zQ8W43oi@Q4YQ>R}+i90G8*GR`&l`j=PDK_n&5^zr5ypn4#HjVo%-U)AID)qLx_}9pb?QPo6s^SieQK7q zgBlf{d1v`ALq$Lk5{x-V$|!o9fjY#|KlDG@f2jeeiN<5~>;Ah%`G!DKe*|{iz+hg} znQt5Abkp^aCT&g}iIc_*(`dC>v0|fYCx#SKgxY)o0rlH=I{0OVG7PEAH@;rrSOhJN zyVc5PIWNIytd4^k7=2J3uQwj2#}$$J-eM55q~`cmD{3Y5!fW|x%vz)X*bWnWp{4o* zYR|wm*3KnZ9_$h*;lyMXXRztjofkC*-f)rfImo$Ja%M+wz;G4sSs>4gixEAo-}PgI z;~o%aC1wNOv-FFxfMszPXgymIKyfY0R2}}s^*DfO0A4w&<&V!YSZ zf1l>3XAC!$)^ug39v8?6c)lP?>+S(+CTS=#k=cWoTtZbtNEe~b?ELdq?%}rH#aJvY z<;W_}&OOb7G(z0|TR}YweX|35{H2s;FN7pTk#&5zyW8*El&p0@tRin|DpT7?<;?@u zD=ruR!mp3G1&bf;`9xjn_z&{9ek-;W> ziyuddAir-ux z58U{(=(&PTb1xY1!JPcnMGw8k5>JqSpYG=}6f>fb5TvTuJ{NORYJahLvA6Yjt;y?4 zjO+;F5_);SFzl<`F!;2~5Ak&ZzJ9adf_umS(af6efeP(pA^H9xkx3fJ<$^2DfdnM3 z=mqY4A_PxA3SD4loC>*Ry*uW74st!g1-N%or4NB~g(vrsiKV-rB|i9u$zSVt2jEe2 zy9?(W9{QnGMo}d`o60EkFielKXc7Hz{n&`X6eg7fR8`dr7pO@o0RZ|xnVr6nu~dk@ zy;S`0W8{96GGTBc#$uhdk5XHP=Y7(0%v8NiF-W4!F~EBJM<{XQIH65|lfw1z&L(AM zV?5+MYU){MvW>{&g3Tl4YUa^3(%Wi!R-AAzQ3A+vmH}i zXgN^L@&TCbM(YwZIY4jPODshjB^}Ee^9H|E*K6Q$?^5E-nZ3E0k~QrD0rU|x*j6@8p(xJ$@5Mwc8`VB; z1a6WjF;r$0@WSXetr=q92k|!x=b@#mmmMsfKhOv|E|-?SRL4=~9)i^QavJq#J$!)q zrPxnAf_C$~Ao{O9u=P8)$k-aq$?wYpyEQ!l%tyDe;VI+Ue!4ZMShlezo7b+DuLG49 zk25B9GuL@8#l>=*PY3JbzheLT6fqA9d2+q^C%S&O*lZov#WF34h|D<8`h4)cY#OYy zStJq43<3DZzoykY9s8)og)(bBo5|#OB22GL@q}f>M>R>ne%oy{DVrb)c%B zlDgRwA>XYH$bDO*t>v?jWzhSc2JzU>o_eZuZE-tQS!j@+!{=i)jky6BraI&e@_SuJ zT6^wD(0Fl`kJnN7bgoMrq*9!auVBM8EU4tIZ~MOfh?myAnf|V`{x??|n0y%yNi>u4 zeU#4|OIk-}_UA!Y>WVB7CLS($_vf5%B|#|O1x3QxY7hk-OY$_uxF9-bw%~(3yijC; zS=GkIZx_M)xdpEgU`Ew-yJ1(iAuqCw1Bkp(R~MqhiLxvN^y zF)f=ebj;cXc(TO8;5?7PM`<{R+OOg)@+x@tlq^9M!Ao`DOBZSe#6%3y=p=$rm#uKk znW2oBuzMeWmHJBgYnJC_MCb$=2)c7(EyA0+?BsPWXWe4 zJ;(;!$^k&Aw3OFTd7kQp3^x7(0rvg_#z_~+AhXk~BECq!T!w!k-*CbNxon0~ZJ2=< z@o%Wc*S~d_(!&$(PRl8yGnMb|vuQt8wb{heJe>3d{40vaH%M#Vh0O zMc48&QlvcW0}gdV3g8X|+d6Va&#bVyoxhkAI8r9IfTh-E3kT`cRtB@YL-=3VkP4Hd z3<@G5>9j~Ni`at3uJ-6nX%C_^+vg%~u;)OE+klvaa9mJsY@cj>g2@@V@m zwP?VRhR1V+Qm*80YyPqM8P#iQgSK=b!cQkPLVB-oCb|ZVSF%+WwK1O-M5@0Y6y1c~ z4rHoW`hJCIKPX~W@&_57&2gYSNn}~c^J>3WsLDr-s|yJSd<*Rkq5m&XJsf;BJ5rl?jhO` zpt&Ng(68KzRPn)%nVe9r$JB+~SdkMJ5 zlwdkooZSXLsdkk2MdRxP{Y}umxxt*@>(sv6nPSk9nKb_4UiqasbjzD#vk#!r|D0X! z3w+`|7BgM#+?TNUj8?JB)Q6$#>s1GnamG}hl_=Kza0n{MXFcY~7%ac4JR0)}BaNpP zQn5BW*{-HJ8dLTsYy!{P8NRvwnRgoWlkw8ghY4sWv!Cn4FZ|9&K7Vzs9&P*4-XONF z(h;$Q;qqTYL!P0r$3vp2T%;znP9xs^PZk)6-n{ExX0)&qn(p-d z?(=lUG&!O5J!xyuoM)1SpPzNTPKqpcj46t8RM4i>jvH(KR~`Zdrn(R^y`;?Xz+CSiXlAbi!(E)5G1+# z%T@7ZDE$3bLnskKmY$s-+;jv<9QcCA<4YVYYQ6ozaLTXU^!P`XS@BB|u@5bcLvWIRsD-BE*F?Qm06V07Lw>5Eg}s30;3#6lz#k~zj))3sG@^t+^X1+8 zrwFZ9+Hj>Q8>B4DSZISK(3;Yk6f`_hwOL#}%*=tVZ5Bz3Y|CQ6GxLcNR1%u=>~b^2 zn;!hvCu#2mnNuSWzLsneo!tDy#OR^gz#s8FeJwRPgM9SXTTaT?cMPTnA zeY4~18=M!0*|h*#XAF2!d_kxTfV;*tpCKw2%5(P8>i$XENM?_+*VJSES}-J3&x=>B zIR3LajE0pQy7AS8?86)@GF{A9r@)@(rQyQzP?n+7i2&`HPzf_rU%jnQ)6zXov*!jy z+}o@7J!OHVJL3hG)4ZCA1|?_>_!jq6c1eXFfx{!Ct=2l9Z;don6UAw7q_=U; zl_5=!{8LD%3~Ik+=+P#kfkV#sFgayS-r&Bk=Z`$x9jp_a=?}^y4pYN;#xSNpZ!!y9 zHtqrn+h9nK{=KsksMmJQxp{!1R_98<$`u+j5V#wccpGE^CUx0Q^)kk*Hqfb^O^+76 z+eL?cbov8MTEiVAe=O0VrG6`;xl)^&UlR#bRQJrTL7GZoyuBU&xSZ8yO;0m- z)e9;?#dC4s%d~aEgbbNmC><`4Dl6gHByKcyf>T@97Td!1^0n5Gc(S<@^bJo2go3^ z=s02qIDH>=t_fSv1eWukcB3OcNt-i^FNo;M=Z5HSsp!Sy?l8VNgEl8V`=|;L>=-QP zuwvTxBg|S6l(!gXvd8Cf<_0t8gjXJ*!7Zc8U_BpMHf9U#3*8R@_h`j>bAnsZlY(kp zv#>M8WPVtb8X-r2cjR_CK#<@1pc^iQ<`rq0mZ2y_UX9W9=QPu3_Ej$l=8NnEd6F~J zYVV(D*&s`q!6FnY|Na0n_sCKs=ts?cxCL(o&tT+~RlAR3RvxDOPN;EBu#u#wCd+gK z9u10Oy6jV#_0f}Jk1g*?p|-X8q&ok-?siV&+>W9u=j+r>j6YnEkNgr~cB-3&SYcufiUb$2XzQyxrct~YvUX5iH2+(lZGp&b zvTJPR0Eg8|iRqnSWcPuxsml0f>gY{JG8dY$V9lFQ_IObgpNO(|pm)~$lp8c8488~B zNt>#VhGM3WbTWh3NDfH#?uMxkVfiPHp^$>x9p5Q|^%$xY6boK7XFhk^+D-=!N~-YJ zTV0&NJL5fC>9?#8QhNyn?^8MS=PXJO4G#WqMLg*36AJo)(&=sA5NgR!*nanS4Mxy0Ye$#cVxW@H>_=03`lHF=2O>577t51ZMO}Yug+wzV=QBB zOcpj$Tvk87_WbJgSARFTsd1g*dUl=p+N)FfCcZhdyW+rrrd)Gg(yTMq($5v zC)}BDNHUT*0;WYI7Z|`w=rPJ%&rV&AyBT!Jtx;8>J~hf~F(?xvEmKNNsl>ILD%u@# z3oCItOPQ3GAre2rgJ*l<;-ur&G=)1psnaF*D2}%EH$n>IZ(>SMnskLbMm!&mx@+Y+ zCen~Z;U`W|o}?}>K0`;IPm5Q{Vw|6HDE@j{vbI;P7c);2=jw~D`S7R<+riwYU!b#l zYt0XxI>(a9$=@N)uJiDu%ieRn$DxL}XqgO0bTLr_(be-m4y0EoU4cZzk^Vj!3Y^F= zA!uILW5Sn~*TNUW4j=Wez+TpcNL6%>HW^JChLhlW#vkVJ6!?6AfrF`uy26F{s+*CV zc4C*tAxsHJPOA-|)rc#X&qcp7M6yL9>bWpcUAVGlH|Y+tuL`H2e%-QC9&JL{;D6DS zHB_aZFuhp=s$L}d3|0Qp-19I@gSGd>%1pM6=_%L^Z+S0 z|HFw`iWu=Eq>yKPT3%y)o!9bue;>;u!CnSChcME-SG}@wL(j1vC-lVxgGP` zDxG83InSDFhNS+6To$!JI&MzgpK}(oyku?oHrCAeVaC)?`?=T-r$5o_&N0QcFEz!` zX=#4_!LN234>HN@uAyoC?za2UQ;D_wem&i`7H)r?6~zcua7iY5ePWGq+LAA$Ys|;L zUledY2^2~S>h?QbIGYtD_lzM0UIHP)P(I!AW&?yi2T5)D9y-BO(8R0xaN#0`Eahk{ zo6aW>^zJzW)GNpc1nI6}lZEJPI7G1U-L@;`Lw(|5Z8tgUAvezp<_JvtkpE4_Sh9~e zm^IDRu!4KPTxWxG_cwH80I`@|4B{txI6O0rcKtrcV{sO|m8ikIyMv ze&})8wd=BlFP-FFS3kC~tJ=ohX`3+H!;L@K;*o&K5v&Z{d(ROkC(N= z-iuP*D6sIzeA3;iJ(3koSM6hg^_V9E9FNtT-_}ZbfCb)Wn3w*o?Z5@wQdn80DS#1PZTcOMezd``A2kp2>ZisY{rpms;|mHcZAS54_Q zXfBV=*f)T>s12g;F$bgW(FU~M${Bhomfg4o!K+R%GbKmi0)T+AKNiJLO;`dD1z)>z zM&GQBAxj!mx3R@Mbk}Aa;Gh6Y^=LqeJcrS;Q=0uVYlGufv17CaMd$(q`pyer^nI*i zh}A;gE7My(yXAwq*nIg)cBQJY$B=3|$E%-Hhq$-1u^7jXgrrc?RGCs@E3eA;kkSuoH*_(h4&cdCXj|Y7v{alvfE&_T5xQ(odl+f=ERjB*VyBfps{$B+dA9jY2Lyr~ ztrVb9&uUOBazHyC#+#lLF7*lK7!&$%eL1;R!J1bMFai>!M>TcmbOSpr294H`V1C~b zjjUhfZ3wz9i?DnSg6{ODwj|A?{i|hta^c$?&C|e#fQ`-yGWO^|sy1^AX+%e75%`tq zV711rshWUUrP~=w>Lb-7KsfBN0?cH;Uc);n2|YZ_-p|hBU5lV=ZevUWH-r4HvL$o* zD8%47cE{feK+NLe@9>~#6VV|GUY*Nw#<)qJ!GMn8=6PzT5W(GiIg4Q|IK`f(xorj$Tt_dv z4C5nr)Yy5JebG79Vfxqg-0YPq-I0}0{RAzh_jko+| zOst8CtbJ^jov|Z+=9Va*;2I?!Dk%YMC0L3iZorI0(5N75*%Cf6wSH-+lgt zi?tyYaRhQl2n}6jBdbD`w8A9wlgwV(ey!)}bK>ZUFQV|Nah||niSS~$@Fqsq)`T|nW^QIC&Q4~D zb+@F6trCcdn_^Ib?P4wMV!#F&*SEMCN5dd$|54EVZH=pewj6G7$K8Ceeqn*XqEgx+ zgC_tYW~sAce?@wvv|;~Ct&bJ&W^)Q&YsT8#{J=VUF-ZDTNDY}=xkhz<7g-y)K&^k? zT7))Xo&Y?7RkSFY8j2JxKv)!QSAjD2&vo|N+FgYxluonjagO7)>&(GVk7@XV*@yw% zPd7Dpt(KfJi;1=qv1gk{32RyrI#XeL+m`IOdB9_wq6KBIZHlnULw|9dq8}gvdq#dK zmth?LcQs%_A2;!urUAK7Tzez^bN9Ab?H@v{^RDZOrkzgMrah#R)P)J@{++ zvqn>y{WBWILu8b5Ex%v8^+UQsjb_dcTgSz`lYQH70bC>3>HzeohnsEQw8+)g& zdN_szABccU1>KI3?gy{loN&~Jz%IqCEypSc_dCXj28+K&hbBB_Lj<~$9^e zUil_*@*#2=QLcIJ8sk2P!|RtCU&}wtgSWAIXky+6C7+QOeRR`bWjV}cQf!d|n$SzA zySIohGV9BLrSg4js!;%jyjhR!(H*{~zYkF`M^;PC7!FkMd} z>A)SQpB^qLC@KsM z#FA6_@I;m1T>in%5`JV9PTfk!U9AHJ(qsjOxgou8#O`cYI^RBcGt+Mm&WDuafPEI6 zp}*ggvdXrgEbTKehO7L@djgnA_M`S8rY->7SevZOg0z9k9Ar>ig+Gy_Zl;lcw@YuQGlODfhnnoJ)fCd zVcQFF&&UU6qstD!Afso1Jz)B19c;%!d{>+cJXt|ubwB8=PdaU{`Zk9gGb;Ez%?oS{+7 zjr53`EQ5^ds&V@2tRvMrl?oq1qt3@?wF*@_JK9^wFCaK`Fc>|5WPOU_dVc-Z48qKD z1LV3LR0sp7=1S1c7Fl6*=??rQ2#{ufrzsncw)5K)C!jd-xutS*#qumixSk0P-E|b{ zW_wySvMk%5*%*8PRh4Oo4&B?{EFQRRAa*%~+8o~Y1(tT?=mtk=K^u8g4e5HKW=(le z0Ab?!Al{t0=7*?AbHY83IIxVe5rDXQniPoSVf&GzY(==8{To7tmhz_LDg-vn8t$~} z%e65mpY8Xa!j-!LjYTp~K2;z;I-7+e{Y#0~Zm9ehAK(UIDaFmaB>3-Q&WS8_Zl&myNtE0HVDMZIBJJwd=d91g(3E*yUM}PRAW)yg9}SVLT+{rJ$bz_cSPr z=*<=&i~Uy&8XK}6F(mA z2?JnHExaKWrPAur#l^)CKT*}?FK11bgn1QmsnR$NG&TA2pT2+RmIYcWsZ87Evw#96 z=mt5Y=31#2z*ZD>Fdly+{NIn5OPJcKQA64{KFjOJ_bs|uV2g@k*uzKYQ%6|R@kFnU z)7d{XSpNhgVrDu764+fNi&(ct8&PNy3oy9>A-pQNXlwz|PIbh6=4_2{G~lVlly^rH zAC=jOSeDz}Zys0FUQ#LCFgzY0rsx9jHe?@6jGOmCioY(X`7Bi-pXW_mlp^JbvbI`8O% z4})x@p+Gf`M1+GVGG$UjbW$~DaBJV(I$Vr321fs!VMcy${vyU55oRo#1Qq$?s$UYp zllq{Oppk~~(w-VQZ-Aha@aC3=A-YH3l$Xmj>fRixxx-XuhbVD%((%yOz@Sj@6igA` z`qkJ5N4GPXH4&@zP}KUR-7vlU~*81>boZ2o;~gMfULU8 zHwV*vPl(!3$hoHeGPrsfTla7)qt)q5=H&3bSXZ5z*D20vg}9;6gG0XT37oOEf(msU zGueMWOutFMcL8q`tSk2C8hp-%klUVA>w&>v^~GuRhQ9w{D^gyZWKk+fCp~(Zjt%GN zL`SHK6Lo0~QiQB{ki{XEp#`06{iiknUQXJ3U(&{yyvoz0xOQ{5j@*!nvDg`QP+M!K z;qr!CnNI)96n=!;`nHGV9@$!#P;)wz6QwK4a%G8 z9$SY4QjUp&H~#nl`17G1XVIT6LS2JHBfrm6uwRjT;0kCBxXnf6@-#5d8AOuf6Z#)i zIWDMMic$6qWAVXWyb^}Q0V=n~N30sM;j~;1M>Ks=>vmuHeb?SKht=TeyFQ2qQnd9i zM+MOGFc=6LJS#hhsPx4$g zXG~?rsA1XfqPt`OL!@7JtpOVV@3+^9LcRy#$h4KUuA5!Fhc}&DTdgkw-?kP8k(K&y zAVZ>wuYJe_1GlV==0NW|^Cvh!L1v*Ss6hA+hJ%XIoD}^xC7Q-@GO7BYMM}{zx}Cw; zw3`8P=%G_y(c0rSvUtuJ&N$XLntQ%>0$OQ7lt7b{-p1e^vcOIZkXE>Gv z6hHL;wfz!*g8tTuow&0YKQ!?q@e~=6NAA`K3#1~9j znClgKl!htUy|4Jix6U#Wv0ll)>-Mv<(rTcP_x5OICdXu@Xr-3YHe1C#?%}cO&J2DA zROs$fH@sINJn459PZ{IoPe`00myzxMqv+A$&SfHx48-1S&vFLl&*_%c(G&l9`(MBP zxJ{a)f$=|X+x$rVahti%SYouXJ(GuE8G%VnL3Lh9NnClJW@#RN%j;BSjq{|S{~076 zmRPeuqUlE)0?fp^J~yFzh?<6DOR) zK5&5N|C)m$^2J#mr*2L&jJX*J04Z`n_8)=-{(y9T-p~77{6F6i`+OoewN}Z*C?mIQ zOT77H_LqLf9KbXGm&rCh(AC{9$=w@ZrXOVZkLt}2`QQph*2)x5oe3_*-b;dUW}7^S z*%dGHJy4?{5$bB(y3^Vazf?6~=l69Nygw!BQoH&>QS}~FjP#iZO7`Lx=n(ZbYgHAi z)j8>@NhYh!-}Sql#U{mO-=94w+p)&`>Nn(RH0sVn*9_Or&3m`!an(A3UYYk^%!N@S zMWSW%$(=ttNv zK4ax%WJziA_<*LMe50uOvB}EHQ^^db+K}TT)Ok25mQknF8jT6ckgR@S9gp>d>m6LP zfHjN`dXa2YjzjmcUa;!cG043)K%(G06N8o4qMXi7P=-fVRyg*#kQ&*F?=g`9-({(S zg&}Ag@3!2|j35qQ4-8z9Z+Wzj8w9qLlZm&B-E*OTM%T+AKb0K+zZ+=H8cQfTdg%S@ zn`;6AUZysI5LyQ(*7U>c(1;1e)y*2-KoB>fWjH?4^SV;mW_oSjFVZ@Hn8yX2_6r-V zdG_ny)0sGl$)ei>VTno4%!L3+@%nyQHPPN&PJusM9!XU38a1|nQP}j~=8fg1crXh( z6No=*w4<7|l+*=j69B$ z&}$RY#wZU*M5dhIYZKBL|3sV&fCh_+iKAi$XJImsRi>krcM6*6qjJ)+U`rpqxVt80 zY!ypNB(8SK%wRt%rft5h%54iQEMw@9{4}*Ypz7?i#zAms`966LbzPdLGr8=~X8pyw zi$a=zVEFJrc}DpwIp-Oys3KM~jJ+h^dTmDjv|UHP59%cAkjXy>A-kNW{bHyqXXlh|<9lM*%^2VXS{k0K zn`ig;_top)B1$=3qj+yNTo6v4hAx&-`yt7ujk4Jlr@Va79OGxcG_LloxgEfGABQkj z5$7H1gS{SQ^;|X(7~Hx(Rg|7q1eyvNMq?Gk{Z%MAmvTS%H#J$Hb3Eg4IXR^Cxt|f& zKExeo^n&QLUG}5ThKE5Dm@xQ~k{;U>IX%y=XuKz0gWLFoCQo{pLgS~gMirIBN6bs? zjd=^LG?``(iTs^MI3XSViY3am^1&oLqTn1NDktR$EZht6SLWc+l@Ny%YXvNuHRrjm z$*X#*rl&uOtCz60KTd3R^Wt*9J~`y$M|xg9e2BL*EwI;RsD6P#YZcDB+?oq?Um-gf zwC`SpI2S^aQ@RzR+(in zwR?bXss+S#%)zv*&|x6d5;A4fMy55`Xj!4s*x9)7(M8de@Cj)y)U&OkUR~2MU1lwI zcdrFT#j?@l6A<>iNtj&c+P3Z$M8n-eeKrDTocdv8IQY}wg6iFgL|i|J3=WOE$2B_# zrf%O3v~b$|uI|Dq`AgXm8QN-0f~5tR{OrbHXFs_X-QDN*ctBkQdvS%p5il9`f-Wus z=OW7;L?|&G@`6?g6I8ff1=_?e1eM6k=ziy2T-hKj9`PA7d^%^y3;B?;CE4j&7Zu<| z&~rLlQIzTF9Q^V&7o_-?8)A-g?BtBby~ZJ|K+lWtUF~eY;`9&It&-!B^;de|(V$9P z<^2N>_4M=xg4`wU@qR%+efq`+{(h}7;sR!~Q{WZ#5I;!Jcn1~y z*W+r#<>58&gs#v1ucCFw&>7J3@y|VHw=FS9dM1Z=u~RJriw^Io03J=v;N|Hu;rIL+ zy^w9)9f{f@F&$T-1&&|upfj|{I$%iIPPjh4cee|myCrZIYfU|c!c#6X<+BJdjyFm; zh*_~H1#6h&<%4MoPj@bUqS-_d$yx4|Sj@1QOX%6|ECMpC4Cz__Z0npbMxteb=!E>3V91zt$39X|;~N5O$kfn&hkvNGG_yG%$t2hfLCVxmG8b~u^e zY+W6VA9EpqyvCt5_mHFA-Lih`^?zBSzlVg!UFX7sP3_1eLY7jp8~YNODpKVPMO#D3EYigQMgltey3(-eSS_JhY;Xq zY-FlpC7XFABdaK*?wV5;9Verjm7voU9br%vk&|0clBS}k9-dH}ma0=9lB55j5)?Ae z5S9nzh}R{%0*dX7{c}v@V?s)fAKggA%g%}P z=@Pla#lLo4FkF@UHPZV^_6csrv*foulY`yY z`onfe6(w7ZsEFem7rpq|nVmV)y)`;lGEukI0n&p^ZNXJaDHdBg(BL<^`5AD)kN)4! zGd_=5Fz6XPWvbOq{wwtMi#`#{^(QE1rjN4eNd)-i{+j$iLmv#&~;Xq6_S$^ zVj`*26e(|It|6@>=5HWnYjN|)fG=D-463Qzz<^@TiR;e?@F*q+%sx88M_q2bUSj?3 zYU#N)Hf_w#iW_e79+MJRK?ibCRvg<03x@x3#OkPzDd>C12A8$Zt5{n&S0ceNZ74Ix z^N|l1yqUrcquH;Zx|>X9{j4nC0PlA@mf`JSp#5Mxz!9*(kFVM zZCn&##a;menMy)!-+&nYufeg$|23$omvyN|+}SSg)kNdZ?((0reruN&f4b5`i|W`1 z?(jgGy#VF;@ifm*_}6M6yJ{f)8i7%qQ)``o!GS4Lah!pPps48W{+QWPQY8{qq9*Q^ zz$U^Q6QmMi03##{djD!^aRw$fwp>T4JLCV6V3$+&m0dK$+&TI5xof4lgJQg4bwg<7 z0RX#-GJOe#TRLNgRWvO{$7J>svaaG4VZvH}Ed-7Iqc`}K;y>P~+RiuS%0x-4msEYG z&Prpxx}H@?x3E-8@Z`XJ8EfIWee&wXKU3rCFv;vVKku9Q8VRN8w?}ikAW%6i)d%Sy zd+vhgtg@|=YUI!}MPC1RIc&4{M+q7U!6FR5g$jn9`&8YqU-HD~`tH_ppm{jp__U-s zM8i!BE4$_?!^!b~0Ion$zjM?gP6u;n?+d+P+?U`M24i$OSYrr#XiyvveI{D#T_RRr zWO8qzcUk@G&^=BtQ4_cH=TR)EYnU<+geKQ zJ7s7mO$N%bQe5u8ATNH2ba5t@Nk7NVfyTsh%-}wo2zxSU-TvQgv}*WyP~%9{5Z@mO z7(7_F+}ZlkEsN{A=v__YqXRa2Ha?Lo!bhF-(D(<;%G;a5?X}_dCQ&}TPRt*$k~t|H zVqoUQwcPi=eO5L{8n(2zMmqIUxlj5kkw+!p{S7L<^a!)??8fHC)@(85cgXT;SZLo5 z)u7oQ-AM-bdY8ju(vw2PSGrbE{Av;t>e}P9aBad$r*4LlX!WhxRSC3fEL(I}S*873 zn9^fIjq0#rI!Ud!<0G58;lxH$ZpgwFna%Nptaag0S-1l!^3z--%Q(loO2^U+wKW%W zsR>1WO!d-ZxXPrz4r#J00=s&-6j|2A#VpOO;uSc<)T>XT+f;u9uqQ{owjIBk35wE` z!w%`{MVSiq;z7u{{cuR%J`~HJrg5)yM3JI?>x1V`M(NB7EY_CSGmx%o`tjFYPN^Dt z3(h6v1%Y>qOEF;`ttzt*di)lRuAd1=7(@S!3wJl2hjsH^&Xyv zvX0;|)X775ovHj$^es`k-^ar${TRv;lzgS%QON#jWUAET=)6yAEI0Hy)z~MfVd~#0 z(z(qy&m z8$83*$1^bTADotX&FTS#VtAYZ8UW@0)~*M*t_QFu>XS$6V*@KODU+ec6SKbRnCz=Q z4OZy~h6{L{yS9#f@;den>aQldze;A-Hq@NF@VM~ieXm>%rn^Zqh6|_WrDUdYDF8uE zYKcN}Zi<5Kbbe_@111Ia=^v#TC54MKb5iq46cth{Qj<$dQb9_l^UE+6Nh%emmgM9o zC*~+5m8NB6rlh3i*`}ldP1#;8!+3ia0ABwp?Cxmj19+T`lu2k4Q5eVhv^8y#n#QD> zxRjS@`(~(4D;~s1acdPpt#v_AN{G#*9ZfUo%*3T_TtK8QsO5>{a`5OuTn8H|O3{NT zN+s$+5V4+A#Ep6=_TrmnVy&5|bC~6u|NDK*``-6(z;b)Qa{Y@`B+$pkVXg6YVD2K$#mj~D7A$Y z96-2XBTlOA4)ChgNHg0iA5oZ-$U{bx(a zyzXL>d~ic^ch^twn2TAf>hpt3J#~wQap>qS6IXETDdcgby*gg>KV)t4$-aVoI+h$c zU9Jt0#S{NQs_6p z_FWse_r5qE|K8)4!ixXmlNo8BDL#>|nw48(a_RE{lfrXfUQ8_i(>xbpUTzM>dHOv+ zNs5OqnD8zS)p>HPENeydQaL-!)V$wq1->Y+pg7G$=A)6ER7OGN!_!@H7Ik$YL8kfg z&59`PW#VMnAuoylDAJA&H%!U(pBl8nA~5NAWQQFl@*X=Bf!gk(dwi_~mRE2bmx)ym zP>d^r7?Ww3p+F5y^Nu!buzqUP+45YNNI*{ zTUOTeOZFQ~uM8y_2OA^KSZ^>F87ufbd^5s2UJ*C&NyM#JOeqaw#Op zJi_bhH`HyCc%IuF+Zhvg$5xIC>m^B)0w|HOWmo(07zq2Z+Wr6#`7q*G`^y`XiEVWH z{G~WX6S1hWa;y}Fv55?hc*^8fJ{rwfm~2`sxz;g_RKF=BXsca4RRVpun&S{@Pu2fDuu8~1Dz>_ zIY5#cQoMkEny*7NisIj}yYv~s@*uDIbQ>F= zx1!XEsenBu{_b$FtS5EwJ}hv!OwO6Ux$4L>n4*42gEQZl{?-dV^76Y=UHA;%P0KU- z)TLIaN^O1)L$04N7$(i{2<~ZkoI7!jefv4~4T5=_vGa>*<%$Vsf+thdyI zd2)TJ_-505O?@PZ$rFBxPR{x&H#sn`iyI-VF}bcliUZDxNs->%xZ=3a=B#f#qX<>OMSd={|;6c$|HbPe>F|9LJg6&4n@3ShvIoevXG# zvLz}ytQb}-DpLMQgpi2m%o}HL{x$E7>yozKBqO9=wRMS(-BO0w2oH7Wkd%kINQX)f zofm=*oq99lDiQcjzxVt7KHvA7@BChGBo{Z5D~g673H^GO;#vA%JD0I+*F?sH{#GgCVIQ7tNv&+*WeY2fHu-D)SCZ_* z$RT!mq?f%NKhEP6>mNJJ>PK7H_E3kvJo@!)EHhtz_fu#of7gY2R(;&yKU-{y`>RWL zVt&uPV==b6)b8J2UQhUg53M-AN$kg~1lumJ_>Z1^I}^{$cmBgC{O2EgFS0j(M7Hod zS#q)CVuCG-sBT+et3WlKz%ZhkD2dV-n#KeWFE~LR8KCHL7`a7okc&+2A`l15x>^Ly zE^r)!?NP_0Ks4Jk6qv-Kqy`>Qij{1r%6kGGFiVJ2XaOM<1?s{z$GOECwZ1oH&Eu&PGax~R-m9$trR|-lNFF{ z(?pgMGI>R(`%#eN3~?Z5;R56+n#3FcOy!Usy1Fk*G;A2P=Sn2_ngNwB5#6y-$4VEc zr?7=xT?Wt6XSr0-z})Wuk5mgf7vZ`trk-nIW!ID)lLAw^Kv(xfBSc1glD(hQPIu;u zuxLb43TKQ`9i5eQqi`WnzLpZ^Dw`=`>qRs4^t8jRd6=6Ec7QKWRwryIcZ5~n*Ht#x zgoZTVT6Xhtx?FuK9Av$NiAv*V;eZevhc$`&ITWlLe z6xH=3Zfw_y^PrAPquWH$?xHldX_sv20Oha=*JLXfn5F$NudHyg&Obi=%3AU*Tj98^j*=n9JBgbi#CTG18+w!U?al zieXaRiUUJ4{|%}9pGeV0#ay#5o>P?BfoPPPWn)TYJJC59w}Q@J9d8ecm%mJjC9T)_ z@$Su`K(XL#*z!TxS=#zmIB85F$yKRYFK}9A5z05^KMYQzDp6gV$%6@*Zf`L{ukn*VnLY|=bJBzjxDW=lbyM_ z*17lOrGuhxWo;;5R%Ye1Nl1%d{!WOE*ZPy{j51}}Rl=1VD*m&x<60ml9=-mY^V9V& zg5s0qH^f7~ub2JrKwM_VAtWx|NIPHM7!5ghtXu|pr585JgbHgCv@$hPwv7hG5mY85 z@w@b|wg)B@nf(yD|NZP&MnrIRSS(I=iIYFaoCj7sUG+|AcvE%M&7&)UXg_)#AKrv-W1 z+{Fwu6X8k` z`~Y+R08%DTGwKh8Rd}5Hc$WReS@sFnO!U%=QuESMb8-|COBB*`6EkxZQu0d_lJj%z zxRexp5{pX|oHG*h(o?MzEEW8dOY)Oai#D?`er9Af(KFC9*!+iSx;T@P-sFp7!pwR~ zTANo(rKxY$a9ZrT`9*v9YN6u%q7sel)XHLw{DP9q{Jdh#?cT9T5!a?{seWaOP3(8@MlTAq=2yW%WHWfi!r=;YHL0@L>%VC3Fj zxR0?x0{|4fSajzChgx`?0Ve?1|MATSz0C)(lNtgdE|bv~69Xqgn>CykyEeaQ-~OVVkux3uijfN7=>do| zc%1uqmi^sX_J%Etr|g-m3a4)@W>nq&#h&r+G60`i3*zhnh+24@0UQA1|MATS?ac?U zsq(X`@*qtDI&qh=a{(o{^gjXprsD<lx}9HZw7AXJTf2_80))PYY)50WWx*dvccj-dXmBEsVUzJlUz0#TxkqC7Jno z#oOhL8INuT0LKpuUf=>Mc$~X;mi^9I_6gSn;?s*#^U_jtaugCv6mpC68eeRE!T9Yd z0Q`;*%-{k2czB%aTF1U%EqlWj#%ounJ6vNt1pq-p2khbl{uOwf0Wtv1|B9{$>8b~? z>M*Y{f)B^!`8JGD30m!#69szJXw@O<9jCz+q)&a^|AQoii_XGY` zc$}443wRV&mi|uX-FZVE-3du5O-Q;S=_G&(EeV7K5QGE)x|*u$bO^!V zFtd&d2ws;v%g9qv9A0WW79)zVx(=f=11t|e(cM+Q`F3_ybaBV;Q;=cLz5UKZ-F(np zRrj28Po3v~Za;Q3>H4>c+is;#tP$pUUF#}^i8VD-{Hbsi;wM^bC;M;cAb~7NoCk|uA0&Rw}-r_rGNF$ z)}~dkotvC;U}JZW-Q{#N$erG9(XA>G6|DYiTbIQ76Q0_XL^p1Mc=E`v%XQUyQe)2{ zg$GCZul)Lk?k9`-eD_u$-%tbj&ED-q*pf%`p3U~({>;yl$*J-@GQ%E^B6Iv#59RA} zqeMnoIqzrzjIcEGSYm?z)Ne1u3)aRiySp=L%_g+l-EK5&J74g>^xDeA+=X_v%gX(# z2(!Xc3QzwY5`=2&_-X=HV+JFNTGhYR3MS6jD0$X7-JKW^i@hF?B&(t$LPs8Y`>VmM zJ^#{>FxuKAx)<$A^3FfAqb-q@dT_mp($LN^y`&9=tpYefQku%{o%^K{;7? zr7^i#^qD)nE*Dwz!EAE&O0NIP2MQE(4TFAQv8Ar_h*3M*KkUHZbA41mKKbx3#C|0& zC9><4kCGGckwCuvWKXtrk?3a09$DW1>6JuM_NO9J{MRWub1kiU7K~);hE%fgugU(; zKl>`h|L!+G1G4R$-e3IfZZL?w9=qFNt{7+Y*t#k#f=#g7m`KufU7$7fU?5pj;>pQz z$wauNC))KKmhYIodnL%B3!jHXf5MG>P+o658sYCcD8R3bv$*H_n|i#gi-X#Lbta*y zzPMRS?)knyp5+i(`(-ZuLJukQ+C>7r7f-Z2VJWMWBKj81IFKwz?{el(ON z`<(9fZinEbFE&EH);b!#jx+Q)MW40ZB`G4?C`!!z`OuIo_KNLZRTSuV{r#jtE(8nRQ2>^S3t0Zt z35reWlDsa*VvozI-Y3eclNoEB*&<9AOg+JS!Gx|e(H9G#@(zqAL5)UOK5nD+ z>(@`zo0{-e5!5bG=ydjoZo$p;m(dckg7>a<#vcNrmWA2Nvd|?0()t_$$`G;3b3_%{f%?x!zf2k3v*Ctr9ckfHNpS+T`6%o zyN!AdLMh!SLwuUE1A{wAL^AF(@OmcPZ6u54zn&jnu_~(Esg7395FW z7)pWe83)BQQ-B(}p&YNi6|lMTt8FHT*XESMT+oWg!XaH=i-);JRArygA<2Rg$O&3& zfx;vVUFHnBuLADXCYD2I5+?7?D)0reI-gpsumZ1tZUrxHeccL|6Bf9+s`JrA&ED=d zQ8ugi4or+C5EiqYZbu+2m>C5(C*pfYLWQyLt;z3?luqwJjwlAn%Bb}nUUxgo!%_@g zMlsT^divrS$RU4dwd(D*&{J}wwJ?uyu^JJ}NorSZ3bo}ks|KQ(?!I3z49{e?&^jAb z`d_*K@wl>pKEn}3EI`Dz>X8&U*7i@@A1A{C?EJJ~3Y-dRL(g7B{P*3ARPw~xL{h&h zMN6Lwek9Ux^)(2Bw2!yv&|~#5XH=-VVdupJXFHRnPp+VQ>ma|9KjYgi1aV^IWqFe3v> z4oVIO`Y9~w&~Y%PMN1-I?JEiOF%KEHf5oKGO{6(Rw2OJAs7UwkA0Hj~pX{Gf6krHJ z-=T)3`NOa4NsC(`C)T)GeQahHs&|deXDyMvo?FJ=6Y7gT6WQp>(<`>Xd(TzKK37vw z%)UcRxle;alF^+X%~jJ~k-#?~?cFBw)!gwZVH=ROhw{k6d1>Uc?wr^+EF?wlHY~}> zPu@tF*ciZ{Y-b(`m4cJEBfCo$?T&SU1w=|hx8!hkI7NqvKpgNfRXFL*=;=+hXkrR?h z@?FG-|4+!)%up+66J3(8u7+&?E|1(Pj~UBh==5-cuHmpUc(d9RkmHlfY6j7*j;32< z3Rj-+7G#E;&oOSy5;tpI4S$A+&)Gr#CRY)&V$QQLOvPJM2%&nr%@+T1#R3B+p%IOT zX0r=DcG+o1Q!q23Z<%$t_f!TVd%_k7cfK&X#l~kcg>uI%xn1j8+-w_$;zl&11p&HX z9w?0^FCCda=4E5{4(Vo!yt_Vd+1@2}E1eN)eK06EZeyW9-c%^K6doDdeAdWN%LqdAnzBq^Xqo23S&SpUi>fIs_+0 z=b(_*+yn7+#XJzAC#`{buxtdBL%*H}FGth9a5t>W4mI|mK8SC#`i%7AT%4xs`$iYa zBBrW>ScUmBcCuhdF&hCwa28-F0kfRQea{sPfeq2p^T^!wnZ?5)$SAXPu79>6avOFd z`}1`%pfD^14HP&G+$uf|Q1~4}%F4%*`JmC--$(n;L3%bYXYI3@PADQVf?R-v$+GS?D*w}5C$m%4! zk2zsrOEF+d9{_u5dzVlhJ}Dg%Qwc1Ts>#C+15fIiD`7%{VP$J|P1RI;RbNBZidC%> ztm9i(E^29AHJ0{22qoG}55kFLlQ26tf!RjVpYF~8QpHM!#r;jJRpSM6xikKpW$M#36xC|LrxHNB8W51bR+}6#AqL^}N809#r#KmNC>U z9p|) z=o_Nur6=GJWJEp1af?s1^vHJDUN%&IOsNW-W^OkdY0s0;`y+45j$EmWz;Ai!GYsl< zR*#*@#q#&WWhkN>H$x`9^p8+K?6}R8E2LEiAxHD z$URxxwHuNXN2$EOEk;0om+10f#Z#&FEIc#ZOBuAs4#53G;(NzII7`nTghPYusgW1p zUS0T?oNG}rkJ>U<1vIWD*ZT9x>988bR!9BB%qO}`ef~;Y6`UTx^ z4$?BY5C-)T{lw^?p$>P$$UmBGdId^@KeJ&Pc`4}YqVRZVKTx5ZSq@?JGgXcsP^kaUJ(O z^5{e7;Hn`K-Yn0V#}!O;WZ85c&If+=$wLX`>`g;>i#u5Rpzr@HoCqPs=PtlwcwKuD z?!>R|iy*L-ORRri1Y^`uD5F|&2}8c0Nst2%N7Ya^AQbbg8Wn~~blVKPtlb9C}ldTsvljs*; zlS~+JgTWZL!59Ikyw!~p9pV8%c$~Yiiv7V#_6=Lhn^h~et5z^-#{vLWb_eU?1fnc> zocr~IZN(3^hAoUw>?fz46PTvKC@^{38NTUC4vdmuhOYyo446^v!05}7T9KNpP@b7L zozs|6W4nBUP(fPg8JFtkv@0tpbB0f!Pu!tExPLfK@~F1sO@c41Q>+3al~ zz`dFOSG8g9zT^8mn)2q&n>Vk{Kiv7J?+c&$ZhQcPI|1%O?*ZAloez3tK!|d5tGU*0 zw3rJ7TR}zV(|v{jRFKO)|B2;1zesY{SHWws(k7k!SrT zN-+2R1gZ9Yd;l5gKLlHQBjsd+f3(zp!9NXapZjM^?TmM2A<9f4R~=ZZH<=hUynAXu zj0EshfP;WD0SRKQ^Jc&WkUB30$)(y4LI03yzXj(wYY}9UEK;JmT{fB1qaY(9g2{bZ zsMNZ7J1`7sP->KJRIq^=A<+_u`8yfe7UGz2IV4u9WrfB_wOOHwQf*6Uq*QAO>qFiQ zjdQg&hsj+HdZQ77$fz(EvSsUk=1|MoFy~U15E}yvf6Gn7-l!?txc^h zv#o}P*=9q7P$;BNpCthjb@Y6)JNi8085tWx=EV$zYO+6O5NOCJG5J`A$7b=dzlLN8 z1^oO*=qgH!bVMy52NrT^h@5oD=V0vzxfaXfI0cr|;x6$rCA!X7YY!CgU%kaD7zLvl zX|j-xwMx>Yn5(divRIlJb=i)JO{LD{Am1z0h$1Flg=JCvik?9QhMxQ>emw&1$&4ni zCN6Q-d>^@XJQ;B?o?KD{ktD&77;3^uNL~=m-JOiumpo3a`H1+tl2d`rOC6S_IXC){rAz$Ch%|v7 zZHEYwxY(cEi%$xuaqx#cl{Og4$o;fop@QCAhqT#h_0~E=osyoI1kt#Y3u$p=?n)Uw z)&ZepPJVEZixdrcukVa>x3;CZMQ=4!TT~W%qrvJ}MA~sxzcNJkY`^gtZZk{JPly$$j_& zO&J5pp^Q=(O@7Q6$FTa7ivA6V?|A?Hyv&bxZjb4lgEOdRY?FI3Q|OuBfr89kA4czI ziG(o}eTgkMoCIYDh1WP&mG(i}GvxHOGr&}7M@};@<3wtN++VSIKJT$;7qL2v)$U+N z`xB|S$zcPO2sM4caJMb#$esbSqukndt7DREU|JNeU5&P4iqSlwwOOTB3t7ToQZ{fY z=*Z=P`@*NE3)w=8-rk7Qu$DfPq$D%)o*OzR#)Wf=)#y4I*|020ZKe#%4Z?Y&E!Ik% zDpyT%(__e_f-!7*!9Xmp6`aTN>EVf?7DmHpqshSdkUff=89p+_t4~^s>xsA$-5Uzg zr0<9bejIYzg2zv$j7a6DEvH`>Ll_qca(Ki51o_K|;o^wDtKBNr=z;yl;V=xZAd zRVejlJ6Tj%Bs_G~vE@y_k0##~s-c{O7p0);4J=xP3%*=bxB;w{sHI`Au znF(IwOm&=gj_6;B8uTcDM`&1jaM`?8y~(Ds8BF!r^s{pi+ncG|H^l=u6QW3VNo=_n za!boXRh_|RR||_5FCG}^VdowO$@f2TQWRp{ULxSG&z0mwj5eCEhA;+aO|sfEHqL0{k)&So-?y7Oack{9yPqZdV-QWpj356tAU@4xXk7; zEoi0Yjj_WR^7WWCye=oJD@wevbbeUT8`Ry&)){L|Msq`Vyc5ZU$7-Rx^Wa$HY+7PqBT}-V8d#lwfq;Rq1T&ZXE+hanTQy$Bso#!f6w^ykR9V*O($!S>HCg-8O+K=UE^5J9+?l^u* zBHN@F$8_ZLb0f&BQF2sE-yM)}EcCC9?yyyV`KHVJ59G+8EZfWC)Wqxpk#{`YZVl$8fGt`Ri z-40P9DT`vruQL=qfH;w7&m5_I_^=bxQGF_T&=f?vW+wGv5cJk+h(~tt0U(T-d1ZH+;nbxyQGCAGF$s6KPMkzpF8Y!AU z3_qP}sUvgrPoQXgrQbl34h6?~pv9np^8(v8vbAPZN{^!&ORLL8{!%k!`9pE2B#)!i za`RxruvO4ot@?$61qnrGT`O^(we5{Yo4{-|*7SCSGYF#LvRI7)8w9sXWH=proNsbc_`g%RIppgrlzQ#+3cXf zooaeA1QN)VwE-m4r1g}eax$#;O3&MOH)APvF%OZ7JaX&RK4f{F49&;-y0zZelj;*m ziQ!rg-BMaLyuLrqY^eXn8)SOJmwkJrtHNAoSn$6iE}1?S4l>f&I2zZuJuZ^SjKyf$ zCK$iW`%i^O4gg?B&%sbKkos_4SHD* z>8RL+L7>T=>@jJK-sUxl>@rn^dBc!PU&fH&=HT9Jb!Bsgr;=8fjV^21(EL%qhmNXj zC_-jOFgM410?qjQOH^3iTM|pO78|dHLjOs#3~FqsZ75 zAuJzNkXIGHq{14Cv!_~T^O-~OEPk?1#(GtIDcNm{!S)$jKg|2Cp2I`P(47cqHH-Ha zn6%jwqyZm?LsfMCVz)rJ2mO^TxU06dS#jNZ-Ryh<={>(cGB|hsV+q~hw1(PNtIgPE zFfAlo=f6MjQ2_2?hL}AtIjAJt7xbU>sCfe<%TQ`D+r^1o|CoXvRd{*p3 z@>lNj6eN#O}pFxgNYv#k*z9EddQdq$?e5aWW}mjUol{z zdEpp$9$yvMhtHQH9#3Ocz3S#Ycfcf~5)q+B*OUWmTDxF^E#_AY)`*%p|C+7osdZ{F#*?#1>&4;W$BO{a7 z$R$i{ERsC6Cc?e#E9q-7)_?iHiLCOzmsyiq?oteh)6!!uEd?>oQNTjI}8$*QnGBvbCFWr z~E#D&R`WILy3T{1La&?PfC+2NY}y95|13W3?gLk2~h|VJIB6ogZZb7L;ZOvWn<<; zC!FWg_wa>6sV>?fuT;vh5s7$Ju5^txRz$wjyLwN3F<#tta z>L4n_{?lz(CY&im2248>Pi@)Y&<-8R=sGB!AY-M$R_hi#|I~Fi*f~~GV|CaE*5~KW z#yV$tU5Xq&KTQ1kK$lE~U=n&E&pB=Mg#`-t#mee1Bya9{MIWB-(AV}u9J{b~;&}X( z#8`J6UgcQH_o^wBOuUEPbz};w&`L9poQhkt@@ltZod@;52%;hIw zIXh}|YqOdKF@Z{}l!@CL4T8P~j~gAO(55%F8pIsjfbmdEtKDP64h$|gjV+-_$o2Nn ze1LZvOg4i!N_L+M49^v^+y~8dW1x7=DAGtiomxh+rd{rBD;PzF|KVd8 z)fxTAVnAux`$iIJdn1F_*meE;Z)9UR^UYYIcyko5WlEnc_rA$K5P$UMw^+XZ?^*mK zXaZ@U7D=enOOMWnSg0cADgSoc9!?7?VZ zpJD1gn2Afh{=qV=zw=QmmZLuI1Rd=thPckqPgeHQvN=i~M`KjSw8d;Unp^cuaGY^v zZHr~LP2Xn7!|1XfHu!)|9O&0(Z1!N*D6;$0Ex5$25@1)Z5iC?gYD+uqe|a0Aw6pj# zTOYL2r@ruK*Y2-;8I7Ify{}GVx#sJYSjxT`j9{8?cKDHr-^O$n|7Z-v(>?U-3M~8I znSkY@JIPpXztezaue*6zCjOR>Wz*e6-k(Gc-Yv)4k9V`AvC*XZw@p}n{hJZbsp?)F zjHa7ZV(yef#KYXTtp^a!Z#B`#hi(LjIg1>2y!E6oQ`L(01hzAzq^yM-_g zjWgDZ#3>t)I#JK-5CDnAq?sQf>*RN8Dr2@GTWGY*7wQa#7M38fAx4y7vPwcO2`Zx#A^~j({UH+eVryd*j0FB2jeZveHNY?VO7Z8JXc&QZ z=z26VRzn{|L%JWM1tV&jmxKpZ90S|jdkUx`7Q&&Du1|tQS`iB=Siia(&&Hzt9CezzNB^ne^$uA^7vFc2s7ih~pQb1Du|i3XA0jDyDbZeJr^ zpVH|<1r)__Tdixfw3_O4EheMA+QOEiE%6W?Dp?xV!7hm17Jq9sgwg**7#f}cLbzA# zp$??qCqN2qNPuwqU@iDLND5YgKi!i6eYUK@&N6yD0ZQmE36M^OM0ERVYY@#z1_3vc z!Ina{&7j{WB5!#|jmWTSapDjfmkjyXRh0}I@aIM{D5Z6}Vg%uu(#~_Gcpr zQiEbcPJ?n$en!)TT=)!se#?bsq-|~<3YeB|%Y$SDKAQ*A@F!{j3bVLgke5fHM+V^0 zm(#lgAYX}LFJ>vu5BB_u#Utp@Qr$pUBfgiQzYc^1U;aKrO_$|D47vYBBAqY@8gTtH zgK*(e8a^0`uvIk}6v&pQ!C*qyKtIZd%h>|VV*2;tFhM46WwH@-7nBkGD&%x= z3xv>)rCdf9j({@6d}#!(t)sF+n2D{XLO3pYQWE+}04*wl``9iVi54uo5JrUS&|~Uq znUw47dX{#R6YoS)C4)cnP6!=e3<8-$P9G~_{asl9QATq|LU4F@ zbvQE_4s`GCnmYwDd!dTbsW6z1uLPNhKbBf6VT?n(u2;fr#E%wRAzAJ$x^N;iCMjnr zh3xL{?66Onq0FRvwGiJGs)cF2pt@^rHTYrxMCVOHhVw{^?wkaHz@sc*jn#lVryU6p z!!=7wZ%#rr($b*GFi4ES^3bSRC!?IE8=LqmNI69dRCEtjF;D=}_o5 zsfFDSxm?BOXdwo+q3%Pk| zE%?%$R_Mo%56|P;EL?vSy)_FK!x(Cs4Kt7l|2`WgM0)H@J)+iH6i7GCfqWwT5JD|; zASBowg6^$@LUQeIeaOZLA9`&LgvuBNWoEl|A(I0N1{g^*^$-(OWi_;+T=Q8iMkpet zh+saO@f9_Z-54w$A@XY44D-gLgO2edL8ZG2#rBwTbo;|Ej&`9d+Lym z6?1{VlU1Pqyo(U{Q)fh!W9d6a-Wog?YJA0MbYm@yVr-;e%ti67r2m|Ykd<^!6X^UV+=<6L#vQaZ(qYHFdo%@|Z^X^sWe;|DW;-FRt;JW?%; zsL@-C1lMtJm}2p*VJ1?w(}KEqG2Wm4(*miYN~AH1mV;w0Esz@IX7EVKU3asn`Wb`*f7^ zF@l!wfXL|X&rHOJg$ac`9&pCIDA2Ct!mhVAh|dY#-nF>r9*z`^MLh97x$KoVOH+~4 zZS&yY@MpLcsdMooglwGFr)#GbO;djs3|qyQ#Iw?Swtwjv)0g$1nU+qs*dVDlc5Rsn za!2iIFNA)$+#eUhIAAYKBAqUL5eyZnFOs=?ZVu${eeUR~l{9KGup`e|jHGMmvc-tG zXGRWVU;Am?5)4?Kk@eIiTr+nqLG{)WS$@3eFCN3b#HA45huy@}Jj^FVoWpR+#0{7L z9b1Y~6I!JQ%b*KkyOyJaE2G~nho7+Z*$PxIE%k3lZLFf1?V!W4743ljiGJFS!9^)O z`2;M)pG=fYPs|iC59<186_SA7I_)VG3tXmTHD)oT^t;u-{F?t7IEbCc*TCn9|MW4; z7tXK634D6gxj`JAa~eYY$`%-EThVC?OF$mf*3hNH-iQT zmuyB=vC#K7LrD*>HfcIRTWO&>0#=On|45*}D?*5Ph8x1hXJ9nCjAPH>zQ)o!&)}M4 zsr*?`fl(V|ke&`qn*DNZ;7K{RVOauAoNsAXg6Z7S(#GF5FwzPlY7OBuJq z*Z5Ph&5<(lmGd#ye`6a8SQV9R$5@LmJK$kURnm*wc_`3#2MUbSh$|$6N?+Ik1Go)$ z=v^7TvqQ1~DRjn8q|ZWaJ23*Nq}O-y{Lkk(7$NsOS@B8HfIy`{o1TM$egYneFdxsy zGT$S8@SNo>egV|73q2xFz>>+lkJ9K{yYTd-n3DUj;$U}C&c6H-U--&P7?JAe zkfUf6HJdV`s=$Yf_Pr9vFLO=C~fUemm z(Di`p>ofiJB%bTrCox^Epi4T@ooeZ6_ESoK=!E_*$S~BNl2dpbJTR|z#OEKMf^sph z?(1Q5s;T8Pn!sv$_B2$xJh2N-E^?`w{`CyHnrfQfg)Xv3M1Sbwh(ce+blwwSMK&g0 zljyORVH^HboP`1G65uSdsEnRH3)B6i=dX163S4jCIhcoh*?*37y;WFSUDPd{(Bkf1 z+$m0RcXxMpcX!tkAh>(6LUE_KQ{0OeDDHmJ_dDNtp8w*{MJ}?J%$+&+T6;|yW3b?_ ztPpI|-##9WqXmvfej-ob8>cBVQ~o2Un^zL1L)ZCz+AbytK;C88>9tieazjz%ECOr$ zss}vh_hWsYN-Bgw&41-Gmyqh2l~U+SiOQo(9|+P(Gs5w#i*f{rQ(~NJ8aK_`A|qQn zC8zMKzV03<6I>OhQC=1*I5BcHkvfU{Mq;{IJ2BQ8TWLr~Y^^6FStV*|C~IpN13^;J zu}u`!g&cEPKC{zkh)}38YbcRX^yrgOaW(-e&={fFq`<>{a%4DHiq|IgZBDBMiYNL9%$eY$8Zj4q!MddDGRm zwImk=%x|hWDWRJ;1E!KHkT_21DdGowtp@wLSo2P%QB;Hza%taawJ2JQS@osZ+POpx z71&`Iq~K1Y6zz{3TWvq2`FqC`Lx$8MNNq=ic=!@6`3L6wBVS(qKT*`N;B?KA;IJb28MCKCbQG&9CmVN# z<%%hn!p?zFBaFfO&rtrKMP(s82}`A6m6i>Gt;*yTml;?g=?rEQd)m->r}3fj`I-R0 zNS*r33G6@Yn6>9jhs*zLlHX+(0b-E4v;Qm;q#-e$eHiPQ&oIV4E~#C(TvbBL$tlS7 zownl#X*VsWfz{J7spQcqv`9Ri>zoe)J~SswD(xS-ifVn{?cxd`)t1n@{Pt_yyA&eaS0jOBP<<_@`Fvdp5 z*f&tZiJ0JR_KvVPW#A_(Sg>Zb8uwRr!vQ5k97MnREBO;(nQ?rvvum_|uH>v#XtMe8 zi{mwAx$IB?Z+2jUq^IqC-ECUnetoO$(Ef4uaVjV`YI+Jt+|4V+YyzO3?1I_HV`B!- zaMUHuNMWO5XVel*`nWZ>s5PJiX{x`dtX6##-Z^-#;$4Q%owaN(#1kfz4Vr~+S zO*+4{_{oahs;pjVQsf9v#Qev2sqd? zjjyWPTBxb1F}^*B1Wy=C3`Wu4Ab4au>1_vQc z-@ZltAW$L$YR-yLmvjr*M2j37k5Ej(%4Ql)nI2}!X3;wpa`;tU@!T80di`@ApSNbV zg3)ZH%C@Fd*6jYHoFMWL6#-Y<2BM#IfBAa*v|i()W~Ir%ZygQocIM=4KP-P23uClI z+x52EViwQ|H#F1wFBE5Y)fhQ$2i8<$A1Q$Ef^XruebC>WAW*1w3#lZG#Y474X85~~ zI`f8WU3gzbqTI#2jYryqZA}DgOk&n9oAsIeI(@r~k3X%!;x~8%`SZ(d#2u;NGJedR zeO`*=;aFJg{2X{kZKh* zLq3UtyBJ&iqH1u0bYB)4*k;_KJ{aQ|fr=tVSreI^CL%7A`yIwqD^^Dn-r_}D4NdlD*=Bv4Z}Y1&_qW*I@+UENhC)hr0wQsTpL&=~ zSn_=P#XBkxFbv!!7wLVwyN$^n7qya)Kg*98i53KNRKyqRc5wenGY{yc%&MnZ~6VU&$^K($o`qKGQ1=g4L zG75pSxh|n-gxDxsPP^5UIUHlP09DCWY+lCWZDq&tLbN+HUL| z38^HiR6gcsN2|z@((4NpcEIs&=qLe{^n;5R-3TxatO{HLVlY z#MRU!7DbP*NP8F?=ygRU)KsvrtzZ^DRD33}Z!It|Z~HDFKa|DVZY;R`u(T!+V!646 zVb?On>`#wafyLkC!L>m|ML5y>T|87&bKA@n=GvS5cz!@T z$+}0Ht{OCGT6I%Ze4v_cwYFrA(?RK~@H(!}ySsEzy;K#mZF4;k(>?0$6w9sBZi&C) zW|ir3<-t;mdHXB`jp+EIFzVcXn0>0`YB}#yzn)(=ncvdgSwX#~E1T|kLQ4n<)5c-A zUY-!!?IY2Ox04Y=TKG$?7}K5AmK0on@EJPWrK1;&$pzxh!!N{d0|!OrU!9$l;B(*C z@}P7x7YG$hoQ^C8InKJoy&ZdESdM#%e);bNd;dU&o&TY>6=K=16TlOG(5?Kk6Uuic z_($I8Lx5&~LD-J}HW~C4EbJfoh^X}=1*x*06jV$&dY{%p3cx zh#Eys?QiOLkVLrz&o`T+Ca^#1-{0k+uY!UJ7hjlRdhWf63*V*5Wv(PSuwI(K4ohE6 zNt11_WA=EU=UP?s5*Z#&2l+q^bQ0iZ!7I=V5-ta*b|!oUJ;OCBeRj>h3Ol)u_&qhJ z$ieDQFImM7&;6X{NkHsNwV>$i(x_3K4Yx(4;C*o{rDzAYl#5cH@gvuf4And8`^QVC zqm`b}4>f&NZ~Ra8+)D?&3`~(D&ew#6+80B*GnW)j>+Z?c+eu>QFTSo}`=+tkd@pUu z8^3=pbv{E0uy!tyYOOpK(|)9I@`4F9nbv8A({yAIhSi1+!Y>#P z*D#sDR@Lt%?d2e4_bv3|Rp$#1xy}GWsXOCZ3X`zp2m(@QR#T8EbFkqmmC61c&IJ!GeUF+%)v}4PNE=})oc=ym| zpgdrqzf>{<)r(JMsuAC}P#@1e63Lf4{QQe3gZ#h|nd7^q_Fqa5;QCoHi;{hDx!b|# zAJ^Yzf7oavP9(?RPHx~uk}~xqh}K~KsmY|#MOYP;N?UtYBnnznx>$k9G&Nsxh=P1) zd-lfN+c=kOkE(oIP|(dk3wM`#GI}6lEDV}zfPK3PhRI-9LwpwT6CVm;H~1ljS~4o* zw*aUv7@S54)^_K9LPgsYM4AUTLTR*36ZMj3z-$Kq5T)LeTtA5w>^UNZ=CgeHDB>Qs zo*zlaq3QT@ynu9HfH_RI^ZonWMW=s*j_dA_mk2=155_iHsAWo6<&St@n(M|J$TjZ; zyH4Eb8 z0c|Ovrx?RE2D-MwfTUuPK`%x~VfH>P_C7!eJ99BE$zPvTB?#W0hM#ik5^?VMvkLUr zg@6XR-u+ikk;MqOejK1r1hoH!s-`Hqr;f8`BLYT(XfP?ym{tN)C~DEi{)5G8PP`c6 zO5I@<>X=jQ+$`I*?-Xu7(phu)SFA|TEq48+xLlN5P> zjPt{X+9<-Vv3=1b3h{B_77ErLRjl0-??fXrjQpN~-TIl8OkwqeXd)fqQlEbBpvD|K z5Zv&QUI%{*-B`PMX+;_Vqdx3c>+stEW`M|tsRfvm4#L&Z<0AzJLNsEM>B26JHNNZ;b62cK>sUnZ4(yxA zQi_WgFxh9Ao4SevY#y>ZDe|o)#N2WNy|~%O2y>9@Tp8!ZBX^Zl4FAMrxciRB`XeJ| zhhDhs^{5cln1UpSd^*1w`xE5G<>A4Lnt5_-Q5;~ze-EjMM>c+`nwy+lW;RZ+Geslk zc$VVoQ1jcW1W^csKy8Y~K+LdK&+J*FKC4zRmxle9Qq~iy1xbOapFzFPc zi24~3_Mt^vVfzJ97+OP-dMYmVuITIscN|=n>XM+(j#SYM2Egx+^tIv-71!|KPh z8C+%0%Cx}oK7YTIK0CF_7@Fyz=l`w*gT)6uvYr=hu%<*_a3+|y*oD~m21M}UH%Hr5 zHbZ$jrYZ1w<%^WoU8~P2=vGNA?#U>diEpJduH6>k;$2B+SSR(qLjKtU0A@25N^UR{$VZe`p=J%i$219 z_FCiQ87D^39c%Hw->B=G5RDyB3!3jdaS68CLf(lm6jx-RROXN5f^IFV5D!oUEzy2i zImy6{YWyWgtyoKbxY+$iMOJ>?Ef&x4Y`hr6&y!ax)#H#to(Mcbb4 zLdC@#&!4&{rsAF_ksW@LgERaDALdGmnDC)M2&qE9@;D=J<{l=$-T3_yPo799;sw)` z=^aDm_rOuU{2P;F!lWeY0;II^-w)C8pYw;jSaN)*osf-V8K1nWlaQFy^Pn53<1SsvwcC zL&{3{U5JlSzk@fEi4S|@1a;u_Tl%1) z4{y8R25geuA!}d_@$8(`<%&C8z?ZK48R8|*@Vv)Kt-o{YGuugA1T0(>BB%1qxe!tT z>x~*w2x+_U`8plxU&zl_2KaT#2)i4CPgjoN-zZ>h4*mvlcs7yHxg577J%Ai)?{Gu* zG+B&R{^rwQx|F=05M1Sw+^qHpP!qpol2ZSlA3Q+^c9?uT~(=U zVBo;v)0N5XS0(CesbjmjhiOSb#F7RI%500aECb#~QXQC=QKpylo0kz%vmhuPDC1@_Lh8i;-BV7&Wz_XUkXyw5NVOG3lbz=+!rR}i$Fdrtu44iEUpc31+eos zdUE*4E>WQmd(dNyAm}XZGG@Wt=Pu?(> zAIbe23V=5O_F?B^=s)mZQ9##w`YX)(3rszjzOjU!lmTR*kKFi43(XNv#MI5n9zy;1 zuY60@$;q9T&d<+}4S^i=q9FlN)co1VI7kfDC^sy3pEOS>e-4!u zK3Go0R>nrf@Vn?gKeTFKpr@m$%9jj~zOH(XQAx5+b+S=9LdmsqDu9!cdcTAoprO9x zXhhZ98u$SazfanK2$it_0bN>q$#&>-YDQjw2K6k#+n>?RSmsPD81p>(bu90-+rL@f z7M&hT#0zW!d^yosj)35je@^yyki(_YzmhbV2KgAxxj7uxF{h+73#2SmKvWdG>NYSf z*B*jl^xVIA8&d<3)@1MQ7wu5yB|t_IHf9?sEf3+pt9KW~Ymw5KqflBpWy}@k<{O;~ z>Dev~IZ)4goOe*5+i4f2JmZ0;70p22C37B+#K|NMLOf{pIjoec>qa-sxCU%{2ka_4 z8m?p7&=MMOC)2|j-D_KQX8eAe~g8<@AhSjvwMo* zmK;4Yfr^I$A=W-99qyW8W!19Asd!xHGx&Wj%in`=-w*}LS*y}c-+33L-a~|!B=(DD zJM)NNUrU-WzflDM5Ld+*|3IaVK!{v`w1B1e*i)F51DJX#`bIoPTjxfr+zbwISQ=2c zG5ObUG*}7@L~Tjd13u}7`e8)xKygEQkpni~Azl9U8klMfneod42~r?}8Et?FjVn`4 zz!rErpt7`(2I|Eg5Mu2ekMXAm?9Iq`f8!%3QU0zGFXK}!0RZ}Vup-AFNFn3#0tWwg zymKm$(=rlR&<2PEVxmLToXhdH%o@_k8lDzg%t|Tk?{Qbby3Lgt8qd^8YJ&!#>Q{eVF<<1<**t zCy)_4GALgW8T8P=5{9MNf~5$|Gba{7c{=$g`G45ykjB$HF!l8ejXI2HA)tYzPhoGh zEpN3z(1+;|6wvtx2tYbe2+;cuY1sTHj~2h2ay^{)I}Jqk{~`2$*{>U56=Jhk@XHe+7Y&(}3{c?o=Q$ ztiC=eIVlq|^o)#H|ig1blywS%ukHfvLwN1u}uKNd{N_WBIKh3^dHP>2~Qx zO$LG36kP0pFf;i1V?0U-mVVn{^8xQ#w)s~?(A{P^aAFqOCC$FiVmObI9J`qLTsUqvomK6Kv09leNb9TbW zxTMXeB{LXTs0wFt6qa+4+M-c0-TD{$K)rQ?5$FeH*=-gAUFIm2KFIG2onm*Vh{e@8 zas#LZXcLv-3M&7+pP#dt!Tu;&JbLpP7%yrc7}Hicm<3vLRL<_Sqv(_^$|VKwhCdJxn#uPf9{{rVuni|riLcHOtup}T-&2-h(&k|58wo(cOyr<7 zBE-fQf-u-dRSJ8!#zMvtP~&MY(7)x9A4uj@!-^@t2bHi315uSrh(o_mGje1SG$u%n zZ5%^R75jfzF`D5nl#S~5y+acK{R%q!2{10q8nV09=Qtd={@A! zDTd*PRxCiOC4AQ&6vW80+j1OERR1-bvnb;-XCG5?oUz(CqaN3u=Jru*9q?rL8QQ}D zym}&iJA;lLguqmujVyEY>$G0SgyYuGjR4)P97zJkB7DmZphakjmu+#cX-^#CPm zuUW!;mYft!KeAFYcQwK@vOLx%2p0dkyXKFF#3<9swlJ;cw*(b(SaYnN`7DO69{~(? zp9}YamXJ9bavVk>!qdfLHY-}0?`(8OgHMFM=8fHB+# z21C}Df1R)YyYpe6=KS9#{&O$@DSp_IZD7n8q>P!bImO{k_TL>_RIMFWvDreDBvuYn zb_yLcj`iQ=(~bXn&(hC=nJ(WW}ef#c|*XWR`8snWnA=YQ$ZdQ3IM|KRq4+ zA-rvVEjgzTY|Y4sR`N=h=2+`5R+1+-r}s#B&?&$&OT^=S{+L8adAEm}k+hl$-eGq3 zqHF2oKHK3`?b_6rwI4-nn5a?QJy58>1b*m|6L80=TWMToNe{B7wEU<;sm zwDoyQ)>=*n+hDI@E|X1$#MR(Dlvlu|vmqRXs#=3yMU_>@;f#V&3S;Fb{|SoaRu>Tj<jOD=OUi4*sqQ*^Ekmje%U$>-Ib(~Rz}{l#6YbF5i8aO{!Q zw5kBdG4iVOClkJnCL#H{1?{5|ihI%c*5P@@>@Qj~hp1avzbVT`V>~o-4lC1O*VXYL z2P#;WT;eVLU^|xU%HJg*R9s~ra^2u!ZIWEPAG4V>=$cxnnq2`6B!B*VOK5j%UlKi6 z)X0F5V77mHE@$r{pDtr`!@V)}o)YWn?5s`d_Ej#*e_roYe`nFtLV|L`4I7T;{k9myxAvO==5qR@GdH%5l}509QP-Uz00*c9VHWrK%QM;ul9%K zs(O1%f2%U|PtE3T0`WT(5gvvsu^IBkh6)mx6=}`^9W?+w5d$Za$G4od8fn`sgUg?< zvTjz*m(A!^n_#78DKm6d^2is{PcbG3h{4$b2*Lv69}D(r{6F=|hW+Mvm9S?6Ch-f>?!7L1zkflBLwpR3@h2PfoWN)j?hLKk-*X(G zi7c7;-bV9u%cB}QU&?0m84iUA{du(0c-Qqa|D86BZT$CK=W(U`K#vAf?DYB{2>U|? z2-%%NfT9`stX+hdR5QpU+m?DdMFa`4#%SOW2*wOjAxz=N_#9PgA|ON_Aauv1AxOf& z;ONT=TUr{zqm|?6(8;gc@jre7k-MohY#+SK#}m@9JH}Y4Uado*%aax@zdcu8$!FTk z30bqnIx;H*>z=cOVd+v_UTfs4)(EaXe()L=$BXN z@#yF0X|3gZDt}s!Rq*h*^xSwV7z{yI0=E8sSv~#w(HY1A=Qft{eTh3>9`h|T+e(4fPkpRL` z3+XfSuGkd+a!&$C_Kh~6^Mg*mTs!1-9sPCyWU}B2AHj=5wwz3WDqeu;f97y>LsS)le+7n0y zPId+|gBYLTTArPOzk#5?5BMPFW<-$VBLWEHQ3GW5j1NM2fdvIUqJsqQ;X%o-&>(Dm zY*5W3F8InAhy{Lk2f~BC-(iD|Jb;p5CV3!Ai-sGpA3q0GNPW*M7_t~fs0YZaX<<#z z1`3Nvh9EdZbi-;2t5asXY0?`(oAxurwkJf-ae04Ea4@p@mg$(eLK3%83-? zq^2$&0ZzVZ=n>zPjcSC(1xj7Y4 zJHL40WY9#(?{EYFpW`h^X>sEhruPs`{jEZ;xtbrp3{zFoF-d*2_&$lyYPo$KF2fX$ z7f%4g6=?laMoKZplb+$QT{Kq)QHp|*sx4Y_cON6ql8(-}X6|f8e4jv+xG)%Hm0&f} z2)lK8db~GUD#wz4Utf&LfG@dDo_D&Ai!(ZRBPCesLn&n!8ts5y$V)ZP%~XNFp^NVg ztd?b!X%F64jPcf7ZvMO^TnIRdX+R_^S;Pkh793hN$B)b%!cEHZ*R6Y!S_R>rlRz#5 zF#X}(wPozfYKYIlFDXwA3zOJ(c`i9>A36-VGrFJaV%V~;g+DC^oyFPEwQjV5-F_1y z9iZX#4CoCFPt9QRI|<^w@27~p6K4p?GSP#>T(d7jF8LO#y%f_;QA&q}q_ zT_-egtgrJ<+<{de5n*|yuMUKHCd*+R&9;spAw|H--ng+936~gw-@X6~g^=~n`BsBU z!kbBoR*wM_d(Z$A5O%uVXa>pwA)@ri%cqn3<|-3fco>f6{$RA=u}q_ z^HrQaftpQKm8G1CchETlv!i{?*_x7MI*Gp=_=Re>&^pepPsl%B)+tlES!8PKOON$oTsPH_N z-7qa$!&t^Xm5^-~eWlWRYyZjA*=dEjLDbC+Vf%~u? z{l7^#+H#wk@V`wO0CLMFK+hD?4OH^DClkceo@=q;pCdI1zs(E1NI}@Q!kWhmn%3o# z!x&BVBG8MXn4jA`F5vxo;MpF_1Lf{K1RkUZ*8%iO5+6Dh$Av%ej|bWSjx#5AJ}`g& zEO_d!0;AXWE-~g!!f1NRI%47)|MWW?m7Gos)gRvbx|WzhXu9`LIJ6sev+-d7pQQlH zZZ|wbZ3if^>m6@)(d1`ejQ`ysifukfM!Fow#%#??1XFJoN=LFrI>Q4sH7m4mLp9Yb zNUBiwRu|^j>+i&;i|;^u?v3dLAEo=Ruz9yb1sLEBC9`|8disStz#v>!W}?n~_5$N6 z^wW>ZsxFrFYZCs$NToAiEaceD#}#(^7pWO}?6B}X_M;QH_9j#^XEGZNktQYaSChw5p*yBvX|%p%HH4OV0I&6>LIM7MV5FV zXM9u;8WDWsIU!m!_%RrW0;^!+YUf5O0Gc5sY*Z^<&H+z}0;xdVN9bTjG00vMfDS}% zsTKo5lYt||fSBNWCm>M^ss-?ZR8)^_=MXRW-^pcb(z7Sb;ivu4XxuMKYFz0nC7k5# z^%q0k0<))S7)e3Tt%0JyrqFAnxL74zu*|u;+#B){U!AV*t;mTG2u4dK95Z?5iq-LQ zg~{U)KyCTc`7g&lsctT@p*5l|HmWW%mNGUn^xBn5mWEY{p}s#vtJ7oK6GKxl;Ot!K zNJDbwF(OhY$dflyN86YgY3lq~gM5|Aiz|>EuXpCl8EDyKA$bdxCxFS11Uv#PUsWbx z4WwKUl)s18=7xS!E)3drDeRqMVwQ4RNEn%bLns8n%nty11J5-9*I1@5E}$ zt0%?9h&))hn$+RJPP}H*bmic)zUE*SAMXV)Lzf@&u*)jeVVm!5bPr{I)o}6s#$J4J zbN(35w)UuoFGLFfut)nj?&$v`@AXhOkSEf>n$kcRXEbOJv3OkRU!iO0@Q|o>z}~6C zimiz#6;(s*DEN71a2L6O&&%#!W6YwmE4Bcubki&-{mmwIUKNzEjjcv9pRv4*M{+yZ zOz>_hZ(EFgK5+*1c0cQ7e#AD%)U3D77?k9vbElTGn$rI%TJncp~+ z2(Xo8Ml4c{uh(*A} za?koz`L#@jWlp`RILFlmGef7qCPwDrPU4=)+Agdh-?DsiS0wGAD70SSt7T@1;sV;l zq=*d&KWt7tLi*zwybcy}EAv59TR)qe2qfp0M^b`XQ^eD7@u<|i8d{#gay2p8dZ>V0 z+IhEM0@d^7Omu4r#h?4YMW^7dP*j~oUD|Uy+trYmEKM8R^|$*A3O~Nv?&GrJ`qNif ztxyYzw4BzSMi{-_gh3Bzlz|o#ri0<79X&>jPBgFWT@|iCbg;ujzDs70TQJAYp$ZL3 zl0dB0(CWpw0kXH_%pTWp45HSjivyR=YVw{GSEz2R%AZ@-1VPc#=CPok198raAwhqy zw?XCWk8ijJ*xGTEK5w$CKb`pH^szt03R(z%WEN2ie6W8#y)IHA%gD{$ARB$wuw2`S4MW1yo6JnsVy#s2F)vL0W~m4yTwxHYt=WIOFo$ zV2y=o`o)1M$obCbg8~zwU6_Q{t2f7bua>AerjU1Z>h*|NNrPiuE#mNrx(vdWX9&_M z4vmpdxN!IVdg9uHYK^kr%SP3spuxCq6|@Ewgh(q5fr~K;ey!RLnl8ks5tlZykSfFU zO^S2`L9w3ONv9#e^>uaDZZJDmP)5PuZC1-JO-nl#aaK<`$EavPjc$)_XWpsHzcz|n z?~Tlg)pmLQnIpiNdl|i7iTUAbIzRt-uR~Abbg6Ehmoy_|_E|eJsX0Yp5e4XOXwZ9J zmw1OK;}XuwPUhInW2Q>DI<0P!E{rtP+yc{2I=-kT-N~`oVMWR6SAz+z{d_?d;qBjY zK#1zREZM1Q>_^JT4NVm!Pv-IZp2(5{h2$jwcM1guMAZM$H$)cKY{hx$G=kNRIxkH- z_YyDK`Sxyt6hFLs(gZ0nJRvH5xvmSmKM5Ewf7#pRbv?Wqc->=%?O9g{^mWZSvIcXfwjD6ZU_qD~_@J2t*hY`Uh1(Gkyr69&i1U{-SxMT|1Z(i?74-`y+d+#cJ}R$dOH(p);DDJg4OAbUd`QgM&Q-JF>4|F zhj-4sj1iM6yC~d-QbbjrYBXFlomRz0w=_#$%^x>gbQ<=s1H!+HNmlsvIn%PUEu6_O z^UI`q)_kLFNUQ#UfUuUUZ(q$!6I{z3wMDv2r8++OAbDk+eB42WXsF1}@NvE)+N?_H zPl@goI-0B0xe}eo#bxdqRoJS+L*ts|NseNbH@OA$G%G$)REN^a`o2(}%2CznN~nIC zyWIl&0i%{Q*d|hH-+CGtG^YDY+X-(Bfra#(Uo1VhOPcvi3J=r@y5$|FMkkg6+!wt;6&T84zxWu)N<5jDr}Afu@bRh7^V%bkbl;y%VZ9GaoH^ z1udGnm&jKI9cb+B5Y(0MD8!GHtY-br z6yphQ<3Z8#3x3?Ydv6tIZ^tKR$5qG2YYlxjkoQIJd2(-ooe_qjOTt%wclIPlT8vt4wmJ2Ue9>0$4R=(Rq!EoT41#Q*jY1P4z6# zWZy>$akRTu5w;~gc*aa_?`hRS^#_b{10YCO%edSN{Y_zu0)k9w^}I>itSU1hvdM@K zHi!}Q3NmDkynh%`+D<=N;K7G_ul`JxH1aDWgm<+(J(;ldUN8gKjX_J{{IM9Keu81e zJXhD}``Llm_EHJIeBGsYXsJ*wmif%QbmU-B1s}#J z>M&OOluhBna(TWJDU{i{c1nySnnKOXb^RWz z?YJ`pJ5Z3C8yVbI(Pt(-D2%=Q*<{P(19tqbYiFvV;rVP5`UXzttEDfg>sdKtvic(6 z%_WpGg#0}EV{|4pzh}AcS4`F%*?rwfWj#%}&k(g5rDtnY?qOdG*_hHdj~6kWT)DG% zT*PO&8L~h%bvn=j+WVD-dQ8{vlOY@bL^029ocqA0(&!y4*yXxoj%DJ>eu%lg7p5=8 z=6L?=(tIJtLO6%{>Phl5PjWd9Gvk(sv8)K({+6zui;)O6Ui;s+p|24*c>|Tq2zs}Q z+Oy``n`+q!KYbmD#u`^`Q`uvsM*JAEW9}iF{K{*J!ZHJ0g79O@FVR#@3nC?=ROH>2 zB@3~UGsZe9u1Ad>vcagd4^Q)R+kt;yk6}_}z8%KEe|!A{w_tbVZ@R`y#c4W;x06?W zOQ{qiG=E%USHYLa_CwHT{w3hnE5uO;DRH`5D5Rk|BnQuXJ%no^gh%hyaEsPs<+%dQ z%CR0GQDm7=m#?g+$ESe?b|R8nTX0&H_SEGN|Gr%F)qHc2m}ArP(|*g^3nS9f@#L_f z!+5D(2LzDyc#}_ahklZe_8!m9o`ds3yrm3J|4mtt3IjqIV5LA}U@GwUOG?riub46P zR%jS_J#PxPe$61KlV;0#o@dAF^B3_L#|ATs=g9B(wn0ou$|2BeuFjk&MkF_)N3&U? zGV25%?IDNgi_bHf$4Xq#NzY(Acixlcn%)g^;YmB3Fl@io*-=AJxyID z(X!kfaTF2)9fy6V5=;~hQ7O1@`zhqwSC>eR_Qi2rDH4bS3e2eja@B)VFnbdf&h8~0 zbb}bia9^`kx}S*+R`ku@E|YJV!=(na#@WaFV(oThsLSekbnYk@{4jvzJUX`#=^S?QJ^}*?b&Ouk5%i zrqzbBtG-V<#D7Dsa5X)*@)i{Pw0TH7Ns>E6Jfznv-pzr%_wrl69u2#PpX%(}u)xj& z&CvX*&-TyAxxJ#xI{F6MI;?f=na0zdHY@sA@#(nf&EB2DAPciW>?oZB z4q8Dv*7$rKK<%%EJ>s_Dc+%<&cOOEsL)1gauplwxgx?C7*?{U76Jb z{7X9$hRmrA6#V)+?$EV}8f~vf(d2J(xRiCGPsLIn-_BW;L!9e~==Ao`oc^3hmkuLf zB_}S!LrX7LtM<#~)M$uM;x9M?h1@QnX>e{)v4w2lZPg81J}Qo3*!4n<(dhQcJDPv+ zQ)$|Q$&sO2>F2eFI{htY|7k^p{fpAyzOO-MsLiS!0z}lhp%f1n<;}kb?)gHYp@xy5|X}lRTiCFsP#FE?R ze>+X&w*_;yct$949Huf54LM)<0}qrXTiSPjU%kUP`ezZg|E_ZkMp$%pf^zbLrI9&9 zL13HS{O~2~&q?I`4iJAR)pyfb?r9M=P(?N<5BPMyCkbc#nA|RA0z6IAfI=5<+!bXT zDP4Ci;HTiumJqD}ofOB~)I3Ozb^bwC%|SyoqAY%k4n|LoSa8{5A36&V>i?Rd*8x68 zE>kk3zDAW2t63XrAPU0m7KzjG>fOSc!-^Ya+*C%W^|zwj!(&?p=}GiaUF>#A{1$Dc zBZ-0Xmnf;WmdB3$#=fP4K>wzO;@&%gvas zQ$VI)=En45(_7oxTK_TS(K^!d6Ol--rQpQCBNO_?H<{ZOx+ndpu$8248gX;)Vlm23O%IjH7^rKrk64yG;XT zWaYfi)er>4Mf*ECz&JiKUru#*-)Yf?zm*MLc%x`p@Lj7&m<+XIcoCfHw)!7#l*YYkB7C?zn{WinvcDf2Ok6$` zHC)L~+B?K3s>LJ;I@JvFQeBjJZHE-Pq+UpcyuFtwoor)LjHz;tynpa`oe?^MO%8&1 zTYO`0_hlB5X{gEwdDxES-)PB-kHPsVRimW<=+PJ+9t7wZiAoC&;3@6CAemF zMYRQGWyzHV+T{hGipyJkYMvSWaPD(nN=9E38$j5y+FXY}>d;K~awg8nx^;r46sJZ} zbosM!nV(15bnGYhM%^@N6t^aR(l$L_WXUMX=j4EJ1;H!&kA~ocuWnD`B9bP_%DaBE zqb=RK&aP$uF+97tIBLG!ai?XnvpY1H!RxF-5Q@aS%$Cv0^xiWf2M(90$tE*?5`Pj4W@p2e4 zLq>CkkvpQ#0rMDRkW6gTxXl#kXTBWbm4qItokMC+2%eEBvgIf(P@m|pNLj?ESCG0` z=0*_O*;ZgRNdHXfjqicvC7P7Hll(ft()BR(uo+NaYB2e52^LNRw zi4Jxv2Q+$PYXqmLw$NN=tLM|-V;ke6=>%1Uq`#txu5Sm`j^?VwEvn*?M^kWyarg(+ z=jPfgJz@vm6uv@f3I~DI``tC@jIe(^C>Dut7k3O|+Bn^* zgO`1$&t2fcr?N7tG?VKXDRvb`-{h?@l-QA|AHuSH-fQftxk=Ff4rWEq z=*Qn9G{zbELPz<1kncUdTs8fsRk2lmbjT^0IR*E{AW~I@P5aT-k8fg<-h~w%-SNu{ zO!x$8n4xe}k7Y@mdfL!*t3S2}+2>lDs z$tvq{JeHjRjjf>l62^%{E!AEnjMou%L*wKgFjc|wsFXZvY2*d#s1BX&1&ck-j&H4K zSV7OvV?sS_d0qsQIhl*O-c~+d!R~6`&DvoD_EwNLOfU+RtrAtSH8gd!js292D!%6S z6A!T!Nb1T=0f}5fQZW9Ba0gsOCaYz9>m!H+Q5a~D#&3u`WplM}ZUZlojQe3A)4?y> zpXH#rq6369u$0d~2J=Hsrk(js9zrLP4fq%c!pWIs1sOUyDLScH`YA^0l|XYF#qK|3 ze2;taVH3hr?qb-I-$w~8Kbik~{+UoPvN|tXM%;t2CGRE;8o8680F`~jXQx0&!mZuL z^lE3mM<`!*VT7or>8AKQmZh7(&mjlB7S_C^4}hE`gpL2wVSto?wfC?d=+JKHdKegR zo*obe#0x_Qf`MUZOochm2Mv~CH13oYw%&H3Qk?@KXKB0D;nmh8$k5>LqK1K)p$R{v4FUn*lo8sup<~h@6(~RzK<#@%2~2O{zmzgmdhiJYkQ$7{0SUlH z(nH+g8T3E~Few9&htSo+-NV(9)XT=v(Uq2*lAMlIK!B8$)Zd?!7EH_tG`O*9AHiBDC2!prU&?7c=zjBn8i3?@QV{tJwZgQU3etxkIu zD3{+((X|ml;NxmDl+lYG(BG4N}T{Jtg%#&K7N7R$I`z(|D0JdrRJ`tiiwbD zNOLH5bg41s-y>7pR0MOU`=*SsoLJB2P3HXO4pnw`4!I;xu;qbvCF~D zhE_}HUZ9y^ra3hw*b%yIT0cwY-t>PA<*TPJ(jjaCek z)5hXmeCe%;2M`Yto6JEx{#b*tdEYnxgc&omrJ^~L*M2I}A0q}v>bO-JAixI?g5Gf~ zX7B{VNu%Qq{=&z7y-q6AD@rL!Tu77Q!XMfLoA}j!?gOYdR7#T&atoq6Q}{~YvdlMxg&>XcspZ90MvjSU5EyST+leB1w<-4(qpt5Cwln zA_~R%Ae2vSuaL@4Lp;jBfvfI$=kJg&;N|KC!;*7kTQ!=B`?UL-r2v;082cgw+>`tF zbF!b;af8=zbG%}MapG>H*uO^x1e5e#DIDX1+_D(#eaR~N- z*qiBtX#*8s8ZL z(B~ZNMQqiu^&pC`qVK5;*yLR~v5;ALs{1wCl_RFzvLuT!!QEaTY#PWL8EJriT|+L<9k&D&ruZhje~7OvR@1lfc2bn4$KSTpeC;R*c`!n5K1VfgV(Dj z8X`_pGJskQVc96wKWyN1UIRu>e$V69&En=bMg+^=g`-j;7qP=W>Ok%U%QeAK6|q6x z@EH=uY0S5Cg|^+d8m%xBYL}nlrepB6pDyj^ZVxTsmP9zT2*Erc01^}A7=p3CQ#6Ao;1inH z0bmH;K8p*Q%z)*mtr7MfL>=X8%+m-=BZ7>jf}`R`U2^SuXmwgopwqaj%KGZZD%sDdB-{4Nyb(O#t(EOz%w zAwCmCow+bm7BWsy82Jj~Np@?ILShc$9u6M-9I*7W0bg2$h+i@Ra~8aah+yKLCi4Qb z69;O*(+Ao;h2GZUq@?)gVJ3wSFycM1;~ zW+*;4RuIxXpPrs0JS_9Wiwv8}BGm<(G%qT3)@fET$R^R_0TcS#BW-KTPVw zouu#$rMQ;wAlodWFZ+FKS#VGCd4jRfpDPw6hL*+#)wm%yE`3MP8TzN3wiXRKKRT@MOs~CCsPvl zm_kmtxe@UVb8h6~Br4=;B(Y3nff#(*`nzGSlBr{qBEL`_A3Q!wxI>s4ly`l*BX_9Mg|wG$b^|pK`78gfe>E7atG6Y z2q*CS#Ipg{qX9Rd0E>e=w}723IOhl!Tq%tkoO78Fb;QOh6-*aMin?c4)=;=33L&~V z&qje`E&^Uiq`KeU-KM6Xj#kx<%aIuy5URw#XZGRtznW^(2A< zO@0F*R8-jGfcO}m%PfQrben_q{S}zJJ7MjyKOD^FJ?b)53wb`)LICqbg4W^!(0^pU zG?kkWCpli$KS4rGnmm^-sx4Cr+{I_18Je zUZn7fS=j2wI5_FwxgLF7#Y`|K)^k6hyA#=(sV^(_w)5kF$m<5YXEP=|>_TixLJ3*R zQhf?>e0@H1)15O7)$3C+BC; zr_E~s*XOq^%Aq{nhtLDj54qMay$c@aFxPK7X>z963m*3o>eXew)?0fnIpKaQ-;f~N z)3+tHMuZSesP6Fe!_H09BuA-ub+X4QdA5SMe|p}8$OWDt2O0Q#KIes6MQ}=5tF!ZR zXNMcDef_Q6t;nR(5he8|KWZn`ZYeYkZf;jpt8c_K(t6HCr#aSWG!r z9XyE@zIUiz#OW1IM=`W*^?@f;`KtUj${-*bx}IJ~@Icql`5Npuo-~)mt5zdM%ht~FH7N7@ z4Cm{r*0)A4ClVMHY?k0gcYM0mfRkLSRD-59vOzS4OfelZ|5=+F3iTR0`Nh09i-LoM_}H0t#6&_a3RFaNN{NUKpv))iM zAZvN&d_V4kSnt9re^<1ja#7Z&%qFTK*4{s6ox`JC#kx*y{53moGZ9g$SMCbY*LUZDSQcO_YcG-_r6g3pyX%6y^_jP+WoGgb>xyI!p*KxKdS@3ro``*b-gv`p*sGi z*bmD7Q9;CZoWU{79Z4ZMRYt(fhCEK)YCI5`aqvw zznWT;KSn#cC_I`=G~zjYKf!6*udKhyzTO43`h}aC^q6dZcq?tB`KiFk4a!P75B>(D z=YzLyMp(2(TKp*NnV>C2(^ckD7QCr;3D*C4@D<4WJU(1Q;)A2bND5g&DvgiEcE-P zKJ{DE=dK}ixAg|L?hqN^w+_b15WYOvn=r}1%Idt)1X1uR_=6jSb$M0)?cmYmPwAe^ zZPGute~-^;9nt3aQn}`L*)*w4NZ{xA7n)rX{fT|N@BF>tX$|eFRx{7x-TKUWhob6C znU9C~9)UW)XVpJh*++#0j~IbXz`AN(#o%G^Ez3#KCLw*EwrPJd9zeM-KgoR>Z}$s1 zBq(_q<@POHhE2h7;`|(qfZaAh}X(kcOwx$F@UgChZScI;5;l?Hc-;ldUhG;8Z zg}pNKn2|M*Ts5S5V5x%Bd#c~B{qxoE{Y7$CJkl@?hPNKich7d6=6NT^yphK@lkm3|@*c==qX~P}9hLjer*Lpnoh~_F+eV#855zmUs&j^j=EMhiEa&TZp^ zXSUuEtMkb?bZXe|oDRhdAMYd+a8kD6XAXvUculTW!M^RQsrU5_*0S~MikKUf8)`}7 zk3VheMWVbZ-+H`h9P+po>Pi6}=Oa|AOz%lkr})lN@Pl*cHpc?Je8v2obtb0Qb-Y?1 zdNj;-Z zN^SY|2l45%b-0=ANy!AVfeI{%mk4e?U>SsV_XxecJx;uo)yeQ;tHzVMW4P#=#T1r# zmCz>S?#AVod-VLjvq>5Q%Y`;h(5;6%y<6E*BbR>|M+R_LzhEu1;|p4P{^Zf@>`v$c z-EJ#D5s1DL6qVP|`FVLC2Khbh%sayEyPv#;+?G)Aq}lC9F5B7OcyfQ*N|u_4<*0xl z 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 diff --git a/common/.vim/bundle/nerdtree/.git/packed-refs b/common/.vim/bundle/nerdtree/.git/packed-refs deleted file mode 100644 index 1a031bf..0000000 --- a/common/.vim/bundle/nerdtree/.git/packed-refs +++ /dev/null @@ -1,23 +0,0 @@ -# pack-refs with: peeled -c3b63d2fd9c929359231363bcabc880ba29eb96e refs/remotes/origin/master -57ccede2509ed5c421cc7baacc9fade973069cd6 refs/remotes/origin/refactor-open -a856622f0cc38223b5147531394829a8456ec566 refs/tags/2.10.0 -95ee07c9d377c4e844d95e5272ea0152323b96e1 refs/tags/2.10.0rc1 -e6d2f12bf68a55f68ec9d99d467042fc799f677d refs/tags/2.11.0 -3cb3227d56959cca112f20973b41327213e3ba5a refs/tags/2.12.0 -0620b91efa4041288dc69325c53b3d98e8478536 refs/tags/2.13.0 -2ca4573b016a150bdb25e6a81062489e10f59463 refs/tags/2.14.0 -5fcdd03f1233305be3277dc72af3d0d1e3a41c9f refs/tags/2.14.1 -090791407e0b451838ad4f2eff086945f81a9d54 refs/tags/2.14.2 -9aba1c17f6a2803a8cc36ffea3d5ca2f63f544b7 refs/tags/2.14.3 -6a77424c253b1e2ec0d8f7d1f00a21b2fb27cb07 refs/tags/2.7.0 -a5bc034851fabe38e53527b569860fdc8a4a8cce refs/tags/2.7.1 -c008fb3983775f553b06db8f806757677b759113 refs/tags/2.8.0 -80e0bca4dc7f5ca80712f501d662efddc83755a7 refs/tags/2.9.0 -6f2401346381ccae42a818cb16ac1c52ee6728e2 refs/tags/3.0.0 -efe03d6988f6835c857ff27c99ebbe6d158a0c78 refs/tags/3.0.1 -bdfac3e25cd37ce757703c569f5abbcd70a2da83 refs/tags/3.1.0 -e7ebee3084cfe97b2084782f004a723f83be243f refs/tags/3.1.1 -241f2e9dfe866010889c9c190278b95080d944ed refs/tags/4.0.0 -153041ac939502746e5a24468910eb7214a3f593 refs/tags/4.1.0 -205367ab3f46dcc88b6ebb819a276e793a21e995 refs/tags/4.2.0 diff --git a/common/.vim/bundle/nerdtree/.git/refs/heads/master b/common/.vim/bundle/nerdtree/.git/refs/heads/master deleted file mode 100644 index 9e24bfd..0000000 --- a/common/.vim/bundle/nerdtree/.git/refs/heads/master +++ /dev/null @@ -1 +0,0 @@ -c3b63d2fd9c929359231363bcabc880ba29eb96e diff --git a/common/.vim/bundle/nerdtree/.git/refs/remotes/origin/HEAD b/common/.vim/bundle/nerdtree/.git/refs/remotes/origin/HEAD deleted file mode 100644 index 6efe28f..0000000 --- a/common/.vim/bundle/nerdtree/.git/refs/remotes/origin/HEAD +++ /dev/null @@ -1 +0,0 @@ -ref: refs/remotes/origin/master diff --git a/common/.vim/bundle/nerdtree/.gitignore b/common/.vim/bundle/nerdtree/.gitignore deleted file mode 100644 index 3698c0e..0000000 --- a/common/.vim/bundle/nerdtree/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -*~ -*.swp -tags diff --git a/common/.vim/bundle/nerdtree/README.markdown b/common/.vim/bundle/nerdtree/README.markdown deleted file mode 100644 index 60869de..0000000 --- a/common/.vim/bundle/nerdtree/README.markdown +++ /dev/null @@ -1,108 +0,0 @@ -The NERD Tree -============= - -Intro ------ - -The NERD tree allows you to explore your filesystem and to open files and -directories. It presents the filesystem to you in the form of a tree which you -manipulate with the keyboard and/or mouse. It also allows you to perform -simple filesystem operations. - -The following features and functionality are provided by the NERD tree: - - * Files and directories are displayed in a hierarchical tree structure - * Different highlighting is provided for the following types of nodes: - * files - * directories - * sym-links - * windows .lnk files - * read-only files - * executable files - * Many (customisable) mappings are provided to manipulate the tree: - * Mappings to open/close/explore directory nodes - * Mappings to open files in new/existing windows/tabs - * Mappings to change the current root of the tree - * Mappings to navigate around the tree - * ... - * Directories and files can be bookmarked. - * Most NERD tree navigation can also be done with the mouse - * Filtering of tree content (can be toggled at runtime) - * custom file filters to prevent e.g. vim backup files being displayed - * optional displaying of hidden files (. files) - * files can be "turned off" so that only directories are displayed - * The position and size of the NERD tree window can be customised - * The order in which the nodes in the tree are listed can be customised. - * A model of your filesystem is created/maintained as you explore it. This - has several advantages: - * All filesystem information is cached and is only re-read on demand - * If you revisit a part of the tree that you left earlier in your - session, the directory nodes will be opened/closed as you left them - * The script remembers the cursor position and window position in the NERD - tree so you can toggle it off (or just close the tree window) and then - reopen it (with NERDTreeToggle) the NERD tree window will appear exactly - as you left it - * You can have a separate NERD tree for each tab, share trees across tabs, - or a mix of both. - * By default the script overrides the default file browser (netw), so if - you :edit a directory a (slighly modified) NERD tree will appear in the - current window - * A programmable menu system is provided (simulates right clicking on a node) - * one default menu plugin is provided to perform basic filesytem - operations (create/delete/move/copy files/directories) - * There's an API for adding your own keymappings - -Installation ------------- - -[pathogen.vim](https://github.com/tpope/vim-pathogen) is the recommended way to install nerdtree. - - cd ~/.vim/bundle - git clone https://github.com/scrooloose/nerdtree.git - -Then reload vim, run `:helptags`, and check out `:help NERD_tree.txt`. - - -Faq ---- - -__Q. Can I have the nerdtree on every tab automatically?__ - -A. Nope. If this is something you want then chances are you aren't using tabs - and buffers as they were intended to be used. Read this - http://stackoverflow.com/questions/102384/using-vims-tabs-like-buffers - - If you are interested in this behaviour then consider [vim-nerdtree-tabs](https://github.com/jistr/vim-nerdtree-tabs) - -__Q. How can I open a NERDTree automatically when vim starts up?__ - -A. Stick this in your vimrc: `autocmd vimenter * NERDTree` - -__Q. How can I open a NERDTree automatically when vim starts up if no files were specified?__ - -A. Stick this in your vimrc `autocmd vimenter * if !argc() | NERDTree | endif` - -__Q. How can I map a specific key or shortcut to open NERDTree?__ - -A. Stick this in your vimrc to open NERDTree with `Ctrl+n` (you can set whatever key you want): `map :NERDTreeToggle` - -__Q. How can I close vim if the only window left open is a NERDTree?__ - -A. Stick this in your vimrc: - - `autocmd bufenter * if (winnr("$") == 1 && exists("b:NERDTreeType") && b:NERDTreeType == "primary") | q | endif` - - -Changelog ---------- - -4.2.0 (2011-12-28) - - * Add NERDTreeDirArrows option to make the UI use pretty arrow chars instead of the old +~| chars to define the tree structure (sickill) - * shift the syntax highlighting out into its own syntax file (gnap) * add some mac specific options to the filesystem menu - for macvim only (andersonfreitas) - * Add NERDTreeMinimalUI option to remove some non functional parts of the nerdtree ui (camthompson) - * tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the new behaviour (benjamingeiger) - * if no name is given to :Bookmark, make it default to the name of the target file/dir (minyoung) - * use 'file' completion when doing copying, create, and move operations (EvanDotPro) - * lots of misc bug fixes (paddyoloughlin, sdewald, camthompson, Vitaly Bogdanov, AndrewRadev, mathias, scottstvnsn, kml, wycats, me RAWR!) - diff --git a/common/.vim/bundle/nerdtree/autoload/nerdtree.vim b/common/.vim/bundle/nerdtree/autoload/nerdtree.vim deleted file mode 100644 index e6054e0..0000000 --- a/common/.vim/bundle/nerdtree/autoload/nerdtree.vim +++ /dev/null @@ -1,1391 +0,0 @@ -if exists("g:loaded_nerdtree_autoload") - finish -endif -let g:loaded_nerdtree_autoload = 1 - -function! nerdtree#version() - return '4.2.0' -endfunction - -" SECTION: General Functions {{{1 -"============================================================ -"FUNCTION: nerdtree#bufInWindows(bnum){{{2 -"[[STOLEN FROM VTREEEXPLORER.VIM]] -"Determine the number of windows open to this buffer number. -"Care of Yegappan Lakshman. Thanks! -" -"Args: -"bnum: the subject buffers buffer number -function! nerdtree#bufInWindows(bnum) - let cnt = 0 - let winnum = 1 - while 1 - let bufnum = winbufnr(winnum) - if bufnum < 0 - break - endif - if bufnum ==# a:bnum - let cnt = cnt + 1 - endif - let winnum = winnum + 1 - endwhile - - return cnt -endfunction - -" FUNCTION: nerdtree#bufNamePrefix() {{{2 -function! nerdtree#bufNamePrefix() - return 'NERD_tree_' -endfunction - -"FUNCTION: nerdtree#checkForBrowse(dir) {{{2 -"inits a secondary nerd tree in the current buffer if appropriate -function! nerdtree#checkForBrowse(dir) - if a:dir != '' && isdirectory(a:dir) - call g:NERDTreeCreator.CreateSecondary(a:dir) - endif -endfunction - -" FUNCTION: nerdtree#completeBookmarks(A,L,P) {{{2 -" completion function for the bookmark commands -function! nerdtree#completeBookmarks(A,L,P) - return filter(g:NERDTreeBookmark.BookmarkNames(), 'v:val =~# "^' . a:A . '"') -endfunction - -"FUNCTION: nerdtree#compareBookmarks(dir) {{{2 -function! nerdtree#compareBookmarks(first, second) - return a:first.compareTo(a:second) -endfunction - -"FUNCTION: nerdtree#compareNodes(dir) {{{2 -function! nerdtree#compareNodes(n1, n2) - return a:n1.path.compareTo(a:n2.path) -endfunction - -" FUNCTION: nerdtree#createDefaultBindings() {{{2 -function! nerdtree#createDefaultBindings() - let s = '' . s:SID() . '_' - - call NERDTreeAddKeyMap({ 'key': '', 'scope': "all", 'callback': s."handleMiddleMouse" }) - call NERDTreeAddKeyMap({ 'key': '', 'scope': "all", 'callback': s."handleLeftClick" }) - call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "DirNode", 'callback': s."activateDirNode" }) - call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "FileNode", 'callback': s."activateFileNode" }) - call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "Bookmark", 'callback': s."activateBookmark" }) - call NERDTreeAddKeyMap({ 'key': '<2-LeftMouse>', 'scope': "all", 'callback': s."activateAll" }) - - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "DirNode", 'callback': s."activateDirNode" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "FileNode", 'callback': s."activateFileNode" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "Bookmark", 'callback': s."activateBookmark" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapActivateNode, 'scope': "all", 'callback': s."activateAll" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Node", 'callback': s."openHSplit" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Node", 'callback': s."openVSplit" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenSplit, 'scope': "Bookmark", 'callback': s."openHSplit" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenVSplit, 'scope': "Bookmark", 'callback': s."openVSplit" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Node", 'callback': s."previewNodeCurrent" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Node", 'callback': s."previewNodeVSplit" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Node", 'callback': s."previewNodeHSplit" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreview, 'scope': "Bookmark", 'callback': s."previewNodeCurrent" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewVSplit, 'scope': "Bookmark", 'callback': s."previewNodeVSplit" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapPreviewSplit, 'scope': "Bookmark", 'callback': s."previewNodeHSplit" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenRecursively, 'scope': "DirNode", 'callback': s."openNodeRecursively" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdir, 'scope': "all", 'callback': s."upDirCurrentRootClosed" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapUpdirKeepOpen, 'scope': "all", 'callback': s."upDirCurrentRootOpen" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChangeRoot, 'scope': "Node", 'callback': s."chRoot" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapChdir, 'scope': "Node", 'callback': s."chCwd" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapQuit, 'scope': "all", 'callback': s."closeTreeWindow" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCWD, 'scope': "all", 'callback': s."chRootCwd" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefreshRoot, 'scope': "all", 'callback': s."refreshRoot" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapRefresh, 'scope': "Node", 'callback': s."refreshCurrent" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapHelp, 'scope': "all", 'callback': s."displayHelp" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleZoom, 'scope': "all", 'callback': s."toggleZoom" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleHidden, 'scope': "all", 'callback': s."toggleShowHidden" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFilters, 'scope': "all", 'callback': s."toggleIgnoreFilter" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleFiles, 'scope': "all", 'callback': s."toggleShowFiles" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapToggleBookmarks, 'scope': "all", 'callback': s."toggleShowBookmarks" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseDir, 'scope': "Node", 'callback': s."closeCurrentDir" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapCloseChildren, 'scope': "DirNode", 'callback': s."closeChildren" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapMenu, 'scope': "Node", 'callback': s."showMenu" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpParent, 'scope': "Node", 'callback': s."jumpToParent" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpFirstChild, 'scope': "Node", 'callback': s."jumpToFirstChild" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpLastChild, 'scope': "Node", 'callback': s."jumpToLastChild" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpRoot, 'scope': "all", 'callback': s."jumpToRoot" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpNextSibling, 'scope': "Node", 'callback': s."jumpToNextSibling" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapJumpPrevSibling, 'scope': "Node", 'callback': s."jumpToPrevSibling" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': "Node", 'callback': s."openInNewTab" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': "Node", 'callback': s."openInNewTabSilent" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTab, 'scope': "Bookmark", 'callback': s."openInNewTab" }) - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenInTabSilent, 'scope': "Bookmark", 'callback': s."openInNewTabSilent" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapOpenExpl, 'scope': "DirNode", 'callback': s."openExplorer" }) - - call NERDTreeAddKeyMap({ 'key': g:NERDTreeMapDeleteBookmark, 'scope': "Bookmark", 'callback': s."deleteBookmark" }) -endfunction - -" FUNCTION: nerdtree#deprecated(func, [msg]) {{{2 -" Issue a deprecation warning for a:func. If a second arg is given, use this -" as the deprecation message -function! nerdtree#deprecated(func, ...) - let msg = a:0 ? a:func . ' ' . a:1 : a:func . ' is deprecated' - - if !exists('s:deprecationWarnings') - let s:deprecationWarnings = {} - endif - if !has_key(s:deprecationWarnings, a:func) - let s:deprecationWarnings[a:func] = 1 - echomsg msg - endif -endfunction - -"FUNCTION: nerdtree#escChars(dir) {{{2 -function! nerdtree#escChars() - if nerdtree#runningWindows() - return " `\|\"#%&,?()\*^<>" - endif - - return " \\`\|\"#%&,?()\*^<>[]" -endfunction - -" FUNCTION: nerdtree#exec(cmd) {{{2 -" same as :exec cmd but eventignore=all is set for the duration -function! nerdtree#exec(cmd) - let old_ei = &ei - set ei=all - exec a:cmd - let &ei = old_ei -endfunction - -" FUNCTION: nerdtree#findAndRevealPath() {{{2 -function! nerdtree#findAndRevealPath() - try - let p = g:NERDTreePath.New(expand("%:p")) - catch /^NERDTree.InvalidArgumentsError/ - call nerdtree#echo("no file for the current buffer") - return - endtry - - if p.isUnixHiddenPath() - let showhidden=g:NERDTreeShowHidden - let g:NERDTreeShowHidden = 1 - endif - - if !nerdtree#treeExistsForTab() - try - let cwd = g:NERDTreePath.New(getcwd()) - catch /^NERDTree.InvalidArgumentsError/ - call nerdtree#echo("current directory does not exist.") - let cwd = p.getParent() - endtry - - if p.isUnder(cwd) - call g:NERDTreeCreator.CreatePrimary(cwd.str()) - else - call g:NERDTreeCreator.CreatePrimary(p.getParent().str()) - endif - else - if !p.isUnder(g:NERDTreeFileNode.GetRootForTab().path) - if !nerdtree#isTreeOpen() - call g:NERDTreeCreator.TogglePrimary('') - else - call nerdtree#putCursorInTreeWin() - endif - let b:NERDTreeShowHidden = g:NERDTreeShowHidden - call nerdtree#chRoot(g:NERDTreeDirNode.New(p.getParent())) - else - if !nerdtree#isTreeOpen() - call g:NERDTreeCreator.TogglePrimary("") - endif - endif - endif - call nerdtree#putCursorInTreeWin() - call b:NERDTreeRoot.reveal(p) - - if p.isUnixHiddenFile() - let g:NERDTreeShowHidden = showhidden - endif -endfunction - -" FUNCTION: nerdtree#has_opt(options, name) {{{2 -function! nerdtree#has_opt(options, name) - return has_key(a:options, a:name) && a:options[a:name] == 1 -endfunction - -" FUNCTION: nerdtree#invokeKeyMap(key) {{{2 -"this is needed since I cant figure out how to invoke dict functions from a -"key map -function! nerdtree#invokeKeyMap(key) - call g:NERDTreeKeyMap.Invoke(a:key) -endfunction - -" FUNCTION: nerdtree#nextBufferName() {{{2 -" returns the buffer name for the next nerd tree -function! nerdtree#nextBufferName() - let name = nerdtree#bufNamePrefix() . nerdtree#nextBufferNumber() - return name -endfunction - -" FUNCTION: nerdtree#nextBufferNumber() {{{2 -" the number to add to the nerd tree buffer name to make the buf name unique -function! nerdtree#nextBufferNumber() - if !exists("s:nextBufNum") - let s:nextBufNum = 1 - else - let s:nextBufNum += 1 - endif - - return s:nextBufNum -endfunction - -" FUNCTION: nerdtree#postSourceActions() {{{2 -function! nerdtree#postSourceActions() - call g:NERDTreeBookmark.CacheBookmarks(0) - call nerdtree#createDefaultBindings() - - "load all nerdtree plugins - runtime! nerdtree_plugin/**/*.vim -endfunction - -"FUNCTION: nerdtree#runningWindows(dir) {{{2 -function! nerdtree#runningWindows() - return has("win16") || has("win32") || has("win64") -endfunction - -" Function: s:SID() {{{2 -function s:SID() - if !exists("s:sid") - let s:sid = matchstr(expand(''), '\zs\d\+\ze_SID$') - endif - return s:sid -endfun - -" FUNCTION: nerdtree#tabpagevar(tabnr, var) {{{2 -function! nerdtree#tabpagevar(tabnr, var) - let currentTab = tabpagenr() - let old_ei = &ei - set ei=all - - exec "tabnext " . a:tabnr - let v = -1 - if exists('t:' . a:var) - exec 'let v = t:' . a:var - endif - exec "tabnext " . currentTab - - let &ei = old_ei - - return v -endfunction - -" Function: nerdtree#treeExistsForBuffer() {{{2 -" Returns 1 if a nerd tree root exists in the current buffer -function! nerdtree#treeExistsForBuf() - return exists("b:NERDTreeRoot") -endfunction - -" Function: nerdtree#treeExistsForTab() {{{2 -" Returns 1 if a nerd tree root exists in the current tab -function! nerdtree#treeExistsForTab() - return exists("t:NERDTreeBufName") -endfunction - -"FUNCTION: nerdtree#treeMarkupReg(dir) {{{2 -function! nerdtree#treeMarkupReg() - if g:NERDTreeDirArrows - return '^\([▾▸] \| \+[▾▸] \| \+\)' - endif - - return '^[ `|]*[\-+~]' -endfunction - -"FUNCTION: nerdtree#treeUpDirLine(dir) {{{2 -function! nerdtree#treeUpDirLine() - return '.. (up a dir)' -endfunction - -"FUNCTION: nerdtree#treeWid(dir) {{{2 -function! nerdtree#treeWid() - return 2 -endfunction - -"FUNCTION: nerdtree#upDir(keepState) {{{2 -"moves the tree up a level -" -"Args: -"keepState: 1 if the current root should be left open when the tree is -"re-rendered -function! nerdtree#upDir(keepState) - let cwd = b:NERDTreeRoot.path.str({'format': 'UI'}) - if cwd ==# "/" || cwd =~# '^[^/]..$' - call nerdtree#echo("already at top dir") - else - if !a:keepState - call b:NERDTreeRoot.close() - endif - - let oldRoot = b:NERDTreeRoot - - if empty(b:NERDTreeRoot.parent) - let path = b:NERDTreeRoot.path.getParent() - let newRoot = g:NERDTreeDirNode.New(path) - call newRoot.open() - call newRoot.transplantChild(b:NERDTreeRoot) - let b:NERDTreeRoot = newRoot - else - let b:NERDTreeRoot = b:NERDTreeRoot.parent - endif - - if g:NERDTreeChDirMode ==# 2 - call b:NERDTreeRoot.path.changeToDir() - endif - - call nerdtree#renderView() - call oldRoot.putCursorHere(0, 0) - endif -endfunction - -" Function: nerdtree#unique(list) {{{2 -" returns a:list without duplicates -function! nerdtree#unique(list) - let uniqlist = [] - for elem in a:list - if index(uniqlist, elem) ==# -1 - let uniqlist += [elem] - endif - endfor - return uniqlist -endfunction - -" SECTION: View Functions {{{1 -"============================================================ -" -"FUNCTION: nerdtree#centerView() {{{2 -"centers the nerd tree window around the cursor (provided the nerd tree -"options permit) -function! nerdtree#centerView() - if g:NERDTreeAutoCenter - let current_line = winline() - let lines_to_top = current_line - let lines_to_bottom = winheight(nerdtree#getTreeWinNum()) - current_line - if lines_to_top < g:NERDTreeAutoCenterThreshold || lines_to_bottom < g:NERDTreeAutoCenterThreshold - normal! zz - endif - endif -endfunction - -" FUNCTION: nerdtree#chRoot(node) {{{2 -" changes the current root to the selected one -function! nerdtree#chRoot(node) - call s:chRoot(a:node) -endfunction -"FUNCTION: nerdtree#closeTree() {{{2 -"Closes the primary NERD tree window for this tab -function! nerdtree#closeTree() - if !nerdtree#isTreeOpen() - throw "NERDTree.NoTreeFoundError: no NERDTree is open" - endif - - if winnr("$") != 1 - if winnr() == nerdtree#getTreeWinNum() - call nerdtree#exec("wincmd p") - let bufnr = bufnr("") - call nerdtree#exec("wincmd p") - else - let bufnr = bufnr("") - endif - - call nerdtree#exec(nerdtree#getTreeWinNum() . " wincmd w") - close - call nerdtree#exec(bufwinnr(bufnr) . " wincmd w") - else - close - endif -endfunction - -"FUNCTION: nerdtree#closeTreeIfOpen() {{{2 -"Closes the NERD tree window if it is open -function! nerdtree#closeTreeIfOpen() - if nerdtree#isTreeOpen() - call nerdtree#closeTree() - endif -endfunction - -"FUNCTION: nerdtree#closeTreeIfQuitOnOpen() {{{2 -"Closes the NERD tree window if the close on open option is set -function! nerdtree#closeTreeIfQuitOnOpen() - if g:NERDTreeQuitOnOpen && nerdtree#isTreeOpen() - call nerdtree#closeTree() - endif -endfunction - -"FUNCTION: nerdtree#dumpHelp {{{2 -"prints out the quick help -function! nerdtree#dumpHelp() - let old_h = @h - if b:treeShowHelp ==# 1 - let @h= "\" NERD tree (" . nerdtree#version() . ") quickhelp~\n" - let @h=@h."\" ============================\n" - let @h=@h."\" File node mappings~\n" - let @h=@h."\" ". (g:NERDTreeMouseMode ==# 3 ? "single" : "double") ."-click,\n" - let @h=@h."\" ,\n" - if b:NERDTreeType ==# "primary" - let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in prev window\n" - else - let @h=@h."\" ". g:NERDTreeMapActivateNode .": open in current window\n" - endif - if b:NERDTreeType ==# "primary" - let @h=@h."\" ". g:NERDTreeMapPreview .": preview\n" - endif - let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n" - let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n" - let @h=@h."\" middle-click,\n" - let @h=@h."\" ". g:NERDTreeMapOpenSplit .": open split\n" - let @h=@h."\" ". g:NERDTreeMapPreviewSplit .": preview split\n" - let @h=@h."\" ". g:NERDTreeMapOpenVSplit .": open vsplit\n" - let @h=@h."\" ". g:NERDTreeMapPreviewVSplit .": preview vsplit\n" - - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Directory node mappings~\n" - let @h=@h."\" ". (g:NERDTreeMouseMode ==# 1 ? "double" : "single") ."-click,\n" - let @h=@h."\" ". g:NERDTreeMapActivateNode .": open & close node\n" - let @h=@h."\" ". g:NERDTreeMapOpenRecursively .": recursively open node\n" - let @h=@h."\" ". g:NERDTreeMapCloseDir .": close parent of node\n" - let @h=@h."\" ". g:NERDTreeMapCloseChildren .": close all child nodes of\n" - let @h=@h."\" current node recursively\n" - let @h=@h."\" middle-click,\n" - let @h=@h."\" ". g:NERDTreeMapOpenExpl.": explore selected dir\n" - - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Bookmark table mappings~\n" - let @h=@h."\" double-click,\n" - let @h=@h."\" ". g:NERDTreeMapActivateNode .": open bookmark\n" - let @h=@h."\" ". g:NERDTreeMapOpenInTab.": open in new tab\n" - let @h=@h."\" ". g:NERDTreeMapOpenInTabSilent .": open in new tab silently\n" - let @h=@h."\" ". g:NERDTreeMapDeleteBookmark .": delete bookmark\n" - - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Tree navigation mappings~\n" - let @h=@h."\" ". g:NERDTreeMapJumpRoot .": go to root\n" - let @h=@h."\" ". g:NERDTreeMapJumpParent .": go to parent\n" - let @h=@h."\" ". g:NERDTreeMapJumpFirstChild .": go to first child\n" - let @h=@h."\" ". g:NERDTreeMapJumpLastChild .": go to last child\n" - let @h=@h."\" ". g:NERDTreeMapJumpNextSibling .": go to next sibling\n" - let @h=@h."\" ". g:NERDTreeMapJumpPrevSibling .": go to prev sibling\n" - - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Filesystem mappings~\n" - let @h=@h."\" ". g:NERDTreeMapChangeRoot .": change tree root to the\n" - let @h=@h."\" selected dir\n" - let @h=@h."\" ". g:NERDTreeMapUpdir .": move tree root up a dir\n" - let @h=@h."\" ". g:NERDTreeMapUpdirKeepOpen .": move tree root up a dir\n" - let @h=@h."\" but leave old root open\n" - let @h=@h."\" ". g:NERDTreeMapRefresh .": refresh cursor dir\n" - let @h=@h."\" ". g:NERDTreeMapRefreshRoot .": refresh current root\n" - let @h=@h."\" ". g:NERDTreeMapMenu .": Show menu\n" - let @h=@h."\" ". g:NERDTreeMapChdir .":change the CWD to the\n" - let @h=@h."\" selected dir\n" - let @h=@h."\" ". g:NERDTreeMapCWD .":change tree root to CWD\n" - - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Tree filtering mappings~\n" - let @h=@h."\" ". g:NERDTreeMapToggleHidden .": hidden files (" . (b:NERDTreeShowHidden ? "on" : "off") . ")\n" - let @h=@h."\" ". g:NERDTreeMapToggleFilters .": file filters (" . (b:NERDTreeIgnoreEnabled ? "on" : "off") . ")\n" - let @h=@h."\" ". g:NERDTreeMapToggleFiles .": files (" . (b:NERDTreeShowFiles ? "on" : "off") . ")\n" - let @h=@h."\" ". g:NERDTreeMapToggleBookmarks .": bookmarks (" . (b:NERDTreeShowBookmarks ? "on" : "off") . ")\n" - - "add quickhelp entries for each custom key map - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Custom mappings~\n" - for i in g:NERDTreeKeyMap.All() - if !empty(i.quickhelpText) - let @h=@h."\" ". i.key .": ". i.quickhelpText ."\n" - endif - endfor - - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Other mappings~\n" - let @h=@h."\" ". g:NERDTreeMapQuit .": Close the NERDTree window\n" - let @h=@h."\" ". g:NERDTreeMapToggleZoom .": Zoom (maximize-minimize)\n" - let @h=@h."\" the NERDTree window\n" - let @h=@h."\" ". g:NERDTreeMapHelp .": toggle help\n" - let @h=@h."\"\n\" ----------------------------\n" - let @h=@h."\" Bookmark commands~\n" - let @h=@h."\" :Bookmark \n" - let @h=@h."\" :BookmarkToRoot \n" - let @h=@h."\" :RevealBookmark \n" - let @h=@h."\" :OpenBookmark \n" - let @h=@h."\" :ClearBookmarks []\n" - let @h=@h."\" :ClearAllBookmarks\n" - silent! put h - elseif g:NERDTreeMinimalUI == 0 - let @h="\" Press ". g:NERDTreeMapHelp ." for help\n" - silent! put h - endif - - let @h = old_h -endfunction - -"FUNCTION: nerdtree#echo {{{2 -"A wrapper for :echo. Appends 'NERDTree:' on the front of all messages -" -"Args: -"msg: the message to echo -function! nerdtree#echo(msg) - redraw - echomsg "NERDTree: " . a:msg -endfunction - -"FUNCTION: nerdtree#echoError {{{2 -"Wrapper for nerdtree#echo, sets the message type to errormsg for this message -"Args: -"msg: the message to echo -function! nerdtree#echoError(msg) - echohl errormsg - call nerdtree#echo(a:msg) - echohl normal -endfunction - -"FUNCTION: nerdtree#echoWarning {{{2 -"Wrapper for nerdtree#echo, sets the message type to warningmsg for this message -"Args: -"msg: the message to echo -function! nerdtree#echoWarning(msg) - echohl warningmsg - call nerdtree#echo(a:msg) - echohl normal -endfunction - -"FUNCTION: nerdtree#firstUsableWindow(){{{2 -"find the window number of the first normal window -function! nerdtree#firstUsableWindow() - let i = 1 - while i <= winnr("$") - let bnum = winbufnr(i) - if bnum != -1 && getbufvar(bnum, '&buftype') ==# '' - \ && !getwinvar(i, '&previewwindow') - \ && (!getbufvar(bnum, '&modified') || &hidden) - return i - endif - - let i += 1 - endwhile - return -1 -endfunction - -"FUNCTION: nerdtree#getPath(ln) {{{2 -"Gets the full path to the node that is rendered on the given line number -" -"Args: -"ln: the line number to get the path for -" -"Return: -"A path if a node was selected, {} if nothing is selected. -"If the 'up a dir' line was selected then the path to the parent of the -"current root is returned -function! nerdtree#getPath(ln) - let line = getline(a:ln) - - let rootLine = g:NERDTreeFileNode.GetRootLineNum() - - "check to see if we have the root node - if a:ln == rootLine - return b:NERDTreeRoot.path - endif - - if !g:NERDTreeDirArrows - " in case called from outside the tree - if line !~# '^ *[|`▸▾ ]' || line =~# '^$' - return {} - endif - endif - - if line ==# nerdtree#treeUpDirLine() - return b:NERDTreeRoot.path.getParent() - endif - - let indent = nerdtree#indentLevelFor(line) - - "remove the tree parts and the leading space - let curFile = nerdtree#stripMarkupFromLine(line, 0) - - let wasdir = 0 - if curFile =~# '/$' - let wasdir = 1 - let curFile = substitute(curFile, '/\?$', '/', "") - endif - - let dir = "" - let lnum = a:ln - while lnum > 0 - let lnum = lnum - 1 - let curLine = getline(lnum) - let curLineStripped = nerdtree#stripMarkupFromLine(curLine, 1) - - "have we reached the top of the tree? - if lnum == rootLine - let dir = b:NERDTreeRoot.path.str({'format': 'UI'}) . dir - break - endif - if curLineStripped =~# '/$' - let lpindent = nerdtree#indentLevelFor(curLine) - if lpindent < indent - let indent = indent - 1 - - let dir = substitute (curLineStripped,'^\\', "", "") . dir - continue - endif - endif - endwhile - let curFile = b:NERDTreeRoot.path.drive . dir . curFile - let toReturn = g:NERDTreePath.New(curFile) - return toReturn -endfunction - -"FUNCTION: nerdtree#getTreeWinNum() {{{2 -"gets the nerd tree window number for this tab -function! nerdtree#getTreeWinNum() - if exists("t:NERDTreeBufName") - return bufwinnr(t:NERDTreeBufName) - else - return -1 - endif -endfunction - -"FUNCTION: nerdtree#indentLevelFor(line) {{{2 -function! nerdtree#indentLevelFor(line) - let level = match(a:line, '[^ \-+~▸▾`|]') / nerdtree#treeWid() - " check if line includes arrows - if match(a:line, '[▸▾]') > -1 - " decrement level as arrow uses 3 ascii chars - let level = level - 1 - endif - return level -endfunction - -"FUNCTION: nerdtree#isTreeOpen() {{{2 -function! nerdtree#isTreeOpen() - return nerdtree#getTreeWinNum() != -1 -endfunction - -"FUNCTION: nerdtree#isWindowUsable(winnumber) {{{2 -"Returns 0 if opening a file from the tree in the given window requires it to -"be split, 1 otherwise -" -"Args: -"winnumber: the number of the window in question -function! nerdtree#isWindowUsable(winnumber) - "gotta split if theres only one window (i.e. the NERD tree) - if winnr("$") ==# 1 - return 0 - endif - - let oldwinnr = winnr() - call nerdtree#exec(a:winnumber . "wincmd p") - let specialWindow = getbufvar("%", '&buftype') != '' || getwinvar('%', '&previewwindow') - let modified = &modified - call nerdtree#exec(oldwinnr . "wincmd p") - - "if its a special window e.g. quickfix or another explorer plugin then we - "have to split - if specialWindow - return 0 - endif - - if &hidden - return 1 - endif - - return !modified || nerdtree#bufInWindows(winbufnr(a:winnumber)) >= 2 -endfunction - -" FUNCTION: nerdtree#jumpToChild(direction) {{{2 -" Args: -" direction: 0 if going to first child, 1 if going to last -function! nerdtree#jumpToChild(currentNode, direction) - if a:currentNode.isRoot() - return nerdtree#echo("cannot jump to " . (a:direction ? "last" : "first") . " child") - end - let dirNode = a:currentNode.parent - let childNodes = dirNode.getVisibleChildren() - - let targetNode = childNodes[0] - if a:direction - let targetNode = childNodes[len(childNodes) - 1] - endif - - if targetNode.equals(a:currentNode) - let siblingDir = a:currentNode.parent.findOpenDirSiblingWithVisibleChildren(a:direction) - if siblingDir != {} - let indx = a:direction ? siblingDir.getVisibleChildCount()-1 : 0 - let targetNode = siblingDir.getChildByIndex(indx, 1) - endif - endif - - call targetNode.putCursorHere(1, 0) - - call nerdtree#centerView() -endfunction - -" FUNCTION: nerdtree#jumpToSibling(currentNode, forward) {{{2 -" moves the cursor to the sibling of the current node in the given direction -" -" Args: -" forward: 1 if the cursor should move to the next sibling, 0 if it should -" move back to the previous sibling -function! nerdtree#jumpToSibling(currentNode, forward) - let sibling = a:currentNode.findSibling(a:forward) - - if !empty(sibling) - call sibling.putCursorHere(1, 0) - call nerdtree#centerView() - endif -endfunction - -"FUNCTION: nerdtree#promptToDelBuffer(bufnum, msg){{{2 -"prints out the given msg and, if the user responds by pushing 'y' then the -"buffer with the given bufnum is deleted -" -"Args: -"bufnum: the buffer that may be deleted -"msg: a message that will be echoed to the user asking them if they wish to -" del the buffer -function! nerdtree#promptToDelBuffer(bufnum, msg) - echo a:msg - if nr2char(getchar()) ==# 'y' - exec "silent bdelete! " . a:bufnum - endif -endfunction - -"FUNCTION: nerdtree#putCursorOnBookmarkTable(){{{2 -"Places the cursor at the top of the bookmarks table -function! nerdtree#putCursorOnBookmarkTable() - if !b:NERDTreeShowBookmarks - throw "NERDTree.IllegalOperationError: cant find bookmark table, bookmarks arent active" - endif - - if g:NERDTreeMinimalUI - return cursor(1, 2) - endif - - let rootNodeLine = g:NERDTreeFileNode.GetRootLineNum() - - let line = 1 - while getline(line) !~# '^>-\+Bookmarks-\+$' - let line = line + 1 - if line >= rootNodeLine - throw "NERDTree.BookmarkTableNotFoundError: didnt find the bookmarks table" - endif - endwhile - call cursor(line, 2) -endfunction - -"FUNCTION: nerdtree#putCursorInTreeWin(){{{2 -"Places the cursor in the nerd tree window -function! nerdtree#putCursorInTreeWin() - if !nerdtree#isTreeOpen() - throw "NERDTree.InvalidOperationError: cant put cursor in NERD tree window, no window exists" - endif - - call nerdtree#exec(nerdtree#getTreeWinNum() . "wincmd w") -endfunction - -"FUNCTION: nerdtree#renderBookmarks {{{2 -function! nerdtree#renderBookmarks() - - if g:NERDTreeMinimalUI == 0 - call setline(line(".")+1, ">----------Bookmarks----------") - call cursor(line(".")+1, col(".")) - endif - - for i in g:NERDTreeBookmark.Bookmarks() - call setline(line(".")+1, i.str()) - call cursor(line(".")+1, col(".")) - endfor - - call setline(line(".")+1, '') - call cursor(line(".")+1, col(".")) -endfunction - -"FUNCTION: nerdtree#renderView {{{2 -"The entry function for rendering the tree -function! nerdtree#renderView() - setlocal modifiable - - "remember the top line of the buffer and the current line so we can - "restore the view exactly how it was - let curLine = line(".") - let curCol = col(".") - let topLine = line("w0") - - "delete all lines in the buffer (being careful not to clobber a register) - silent 1,$delete _ - - call nerdtree#dumpHelp() - - "delete the blank line before the help and add one after it - if g:NERDTreeMinimalUI == 0 - call setline(line(".")+1, "") - call cursor(line(".")+1, col(".")) - endif - - if b:NERDTreeShowBookmarks - call nerdtree#renderBookmarks() - endif - - "add the 'up a dir' line - if !g:NERDTreeMinimalUI - call setline(line(".")+1, nerdtree#treeUpDirLine()) - call cursor(line(".")+1, col(".")) - endif - - "draw the header line - let header = b:NERDTreeRoot.path.str({'format': 'UI', 'truncateTo': winwidth(0)}) - call setline(line(".")+1, header) - call cursor(line(".")+1, col(".")) - - "draw the tree - let old_o = @o - let @o = b:NERDTreeRoot.renderToString() - silent put o - let @o = old_o - - "delete the blank line at the top of the buffer - silent 1,1delete _ - - "restore the view - let old_scrolloff=&scrolloff - let &scrolloff=0 - call cursor(topLine, 1) - normal! zt - call cursor(curLine, curCol) - let &scrolloff = old_scrolloff - - setlocal nomodifiable -endfunction - -"FUNCTION: nerdtree#renderViewSavingPosition {{{2 -"Renders the tree and ensures the cursor stays on the current node or the -"current nodes parent if it is no longer available upon re-rendering -function! nerdtree#renderViewSavingPosition() - let currentNode = g:NERDTreeFileNode.GetSelected() - - "go up the tree till we find a node that will be visible or till we run - "out of nodes - while currentNode != {} && !currentNode.isVisible() && !currentNode.isRoot() - let currentNode = currentNode.parent - endwhile - - call nerdtree#renderView() - - if currentNode != {} - call currentNode.putCursorHere(0, 0) - endif -endfunction -" -"FUNCTION: nerdtree#restoreScreenState() {{{2 -" -"Sets the screen state back to what it was when nerdtree#saveScreenState was last -"called. -" -"Assumes the cursor is in the NERDTree window -function! nerdtree#restoreScreenState() - if !exists("b:NERDTreeOldTopLine") || !exists("b:NERDTreeOldPos") || !exists("b:NERDTreeOldWindowSize") - return - endif - exec("silent vertical resize ".b:NERDTreeOldWindowSize) - - let old_scrolloff=&scrolloff - let &scrolloff=0 - call cursor(b:NERDTreeOldTopLine, 0) - normal! zt - call setpos(".", b:NERDTreeOldPos) - let &scrolloff=old_scrolloff -endfunction - -"FUNCTION: nerdtree#saveScreenState() {{{2 -"Saves the current cursor position in the current buffer and the window -"scroll position -function! nerdtree#saveScreenState() - let win = winnr() - try - call nerdtree#putCursorInTreeWin() - let b:NERDTreeOldPos = getpos(".") - let b:NERDTreeOldTopLine = line("w0") - let b:NERDTreeOldWindowSize = winwidth("") - call nerdtree#exec(win . "wincmd w") - catch /^NERDTree.InvalidOperationError/ - endtry -endfunction - -"FUNCTION: nerdtree#stripMarkupFromLine(line, removeLeadingSpaces){{{2 -"returns the given line with all the tree parts stripped off -" -"Args: -"line: the subject line -"removeLeadingSpaces: 1 if leading spaces are to be removed (leading spaces = -"any spaces before the actual text of the node) -function! nerdtree#stripMarkupFromLine(line, removeLeadingSpaces) - let line = a:line - "remove the tree parts and the leading space - let line = substitute (line, nerdtree#treeMarkupReg(),"","") - - "strip off any read only flag - let line = substitute (line, ' \[RO\]', "","") - - "strip off any bookmark flags - let line = substitute (line, ' {[^}]*}', "","") - - "strip off any executable flags - let line = substitute (line, '*\ze\($\| \)', "","") - - let wasdir = 0 - if line =~# '/$' - let wasdir = 1 - endif - let line = substitute (line,' -> .*',"","") " remove link to - if wasdir ==# 1 - let line = substitute (line, '/\?$', '/', "") - endif - - if a:removeLeadingSpaces - let line = substitute (line, '^ *', '', '') - endif - - return line -endfunction - -"SECTION: Interface bindings {{{1 -"============================================================ - -"FUNCTION: s:activateAll() {{{2 -"handle the user activating the updir line -function! s:activateAll() - if getline(".") ==# nerdtree#treeUpDirLine() - return nerdtree#upDir(0) - endif -endfunction -"FUNCTION: s:activateDirNode() {{{2 -"handle the user activating a tree node -function! s:activateDirNode(node) - call a:node.activate({'reuse': 1}) -endfunction - -"FUNCTION: s:activateFileNode() {{{2 -"handle the user activating a tree node -function! s:activateFileNode(node) - call a:node.activate({'reuse': 1, 'where': 'p'}) -endfunction - -"FUNCTION: s:activateBookmark() {{{2 -"handle the user activating a bookmark -function! s:activateBookmark(bm) - call a:bm.activate(!a:bm.path.isDirectory ? {'where': 'p'} : {}) -endfunction - -" FUNCTION: nerdtree#bookmarkNode(name) {{{2 -" Associate the current node with the given name -function! nerdtree#bookmarkNode(...) - let currentNode = g:NERDTreeFileNode.GetSelected() - if currentNode != {} - let name = a:1 - if empty(name) - let name = currentNode.path.getLastPathComponent(0) - endif - try - call currentNode.bookmark(name) - call nerdtree#renderView() - catch /^NERDTree.IllegalBookmarkNameError/ - call nerdtree#echo("bookmark names must not contain spaces") - endtry - else - call nerdtree#echo("select a node first") - endif -endfunction - -" FUNCTION: s:chCwd(node) {{{2 -function! s:chCwd(node) - try - call a:node.path.changeToDir() - catch /^NERDTree.PathChangeError/ - call nerdtree#echoWarning("could not change cwd") - endtry -endfunction - -" FUNCTION: s:chRoot(node) {{{2 -" changes the current root to the selected one -function! s:chRoot(node) - call a:node.makeRoot() - call nerdtree#renderView() - call b:NERDTreeRoot.putCursorHere(0, 0) -endfunction - -" FUNCTION: s:chRootCwd() {{{2 -" changes the current root to CWD -function! s:chRootCwd() - try - let cwd = g:NERDTreePath.New(getcwd()) - catch /^NERDTree.InvalidArgumentsError/ - call nerdtree#echo("current directory does not exist.") - return - endtry - if cwd.str() == g:NERDTreeFileNode.GetRootForTab().path.str() - return - endif - call nerdtree#chRoot(g:NERDTreeDirNode.New(cwd)) -endfunction - -" FUNCTION: nerdtree#clearBookmarks(bookmarks) {{{2 -function! nerdtree#clearBookmarks(bookmarks) - if a:bookmarks ==# '' - let currentNode = g:NERDTreeFileNode.GetSelected() - if currentNode != {} - call currentNode.clearBookmarks() - endif - else - for name in split(a:bookmarks, ' ') - let bookmark = g:NERDTreeBookmark.BookmarkFor(name) - call bookmark.delete() - endfor - endif - call nerdtree#renderView() -endfunction - -" FUNCTION: s:closeChildren(node) {{{2 -" closes all childnodes of the current node -function! s:closeChildren(node) - call a:node.closeChildren() - call nerdtree#renderView() - call a:node.putCursorHere(0, 0) -endfunction - -" FUNCTION: s:closeCurrentDir(node) {{{2 -" closes the parent dir of the current node -function! s:closeCurrentDir(node) - let parent = a:node.parent - if parent ==# {} || parent.isRoot() - call nerdtree#echo("cannot close tree root") - else - call a:node.parent.close() - call nerdtree#renderView() - call a:node.parent.putCursorHere(0, 0) - endif -endfunction - -" FUNCTION: s:closeTreeWindow() {{{2 -" close the tree window -function! s:closeTreeWindow() - if b:NERDTreeType ==# "secondary" && b:NERDTreePreviousBuf != -1 - exec "buffer " . b:NERDTreePreviousBuf - else - if winnr("$") > 1 - call nerdtree#closeTree() - else - call nerdtree#echo("Cannot close last window") - endif - endif -endfunction - -" FUNCTION: s:deleteBookmark(bm) {{{2 -" if the cursor is on a bookmark, prompt to delete -function! s:deleteBookmark(bm) - echo "Are you sure you wish to delete the bookmark:\n\"" . a:bm.name . "\" (yN):" - - if nr2char(getchar()) ==# 'y' - try - call a:bm.delete() - call nerdtree#renderView() - redraw - catch /^NERDTree/ - call nerdtree#echoWarning("Could not remove bookmark") - endtry - else - call nerdtree#echo("delete aborted" ) - endif - -endfunction - -" FUNCTION: s:displayHelp() {{{2 -" toggles the help display -function! s:displayHelp() - let b:treeShowHelp = b:treeShowHelp ? 0 : 1 - call nerdtree#renderView() - call nerdtree#centerView() -endfunction - -"FUNCTION: s:handleLeftClick() {{{2 -"Checks if the click should open the current node -function! s:handleLeftClick() - let currentNode = g:NERDTreeFileNode.GetSelected() - if currentNode != {} - - "the dir arrows are multibyte chars, and vim's string functions only - "deal with single bytes - so split the line up with the hack below and - "take the line substring manually - let line = split(getline(line(".")), '\zs') - let startToCur = "" - for i in range(0,len(line)-1) - let startToCur .= line[i] - endfor - - if currentNode.path.isDirectory - if startToCur =~# nerdtree#treeMarkupReg() && startToCur =~# '[+~▾▸] \?$' - call currentNode.activate() - return - endif - endif - - if (g:NERDTreeMouseMode ==# 2 && currentNode.path.isDirectory) || g:NERDTreeMouseMode ==# 3 - let char = strpart(startToCur, strlen(startToCur)-1, 1) - if char !~# nerdtree#treeMarkupReg() - if currentNode.path.isDirectory - call currentNode.activate() - else - call currentNode.activate({'reuse': 1, 'where': 'p'}) - endif - return - endif - endif - endif -endfunction - -" FUNCTION: s:handleMiddleMouse() {{{2 -function! s:handleMiddleMouse() - let curNode = g:NERDTreeFileNode.GetSelected() - if curNode ==# {} - call nerdtree#echo("Put the cursor on a node first" ) - return - endif - - if curNode.path.isDirectory - call nerdtree#openExplorer(curNode) - else - call curNode.open({'where': 'h'}) - endif -endfunction - -" FUNCTION: s:jumpToFirstChild() {{{2 -" wrapper for the jump to child method -function! s:jumpToFirstChild(node) - call nerdtree#jumpToChild(a:node, 0) -endfunction - -" FUNCTION: s:jumpToLastChild() {{{2 -" wrapper for the jump to child method -function! s:jumpToLastChild(node) - call nerdtree#jumpToChild(a:node, 1) -endfunction - -" FUNCTION: s:jumpToParent(node) {{{2 -" moves the cursor to the parent of the current node -function! s:jumpToParent(node) - if !empty(a:node.parent) - call a:node.parent.putCursorHere(1, 0) - call nerdtree#centerView() - else - call nerdtree#echo("cannot jump to parent") - endif -endfunction - -" FUNCTION: s:jumpToRoot() {{{2 -" moves the cursor to the root node -function! s:jumpToRoot() - call b:NERDTreeRoot.putCursorHere(1, 0) - call nerdtree#centerView() -endfunction - -" FUNCTION: s:jumpToNextSibling(node) {{{2 -function! s:jumpToNextSibling(node) - call nerdtree#jumpToSibling(a:node, 1) -endfunction - -" FUNCTION: s:jumpToPrevSibling(node) {{{2 -function! s:jumpToPrevSibling(node) - call nerdtree#jumpToSibling(a:node, 0) -endfunction - -" FUNCTION: nerdtree#openBookmark(name) {{{2 -" put the cursor on the given bookmark and, if its a file, open it -function! nerdtree#openBookmark(name) - try - let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0) - call targetNode.putCursorHere(0, 1) - redraw! - catch /^NERDTree.BookmarkedNodeNotFoundError/ - call nerdtree#echo("note - target node is not cached") - let bookmark = g:NERDTreeBookmark.BookmarkFor(a:name) - let targetNode = g:NERDTreeFileNode.New(bookmark.path) - endtry - if targetNode.path.isDirectory - call targetNode.openExplorer() - else - call targetNode.open({'where': 'p'}) - endif -endfunction - -" FUNCTION: s:openHSplit(target) {{{2 -function! s:openHSplit(target) - call a:target.activate({'where': 'h'}) -endfunction - -" FUNCTION: s:openVSplit(target) {{{2 -function! s:openVSplit(target) - call a:target.activate({'where': 'v'}) -endfunction - -" FUNCTION: s:openExplorer(node) {{{2 -function! s:openExplorer(node) - call a:node.openExplorer() -endfunction - -" FUNCTION: s:openInNewTab(target) {{{2 -function! s:openInNewTab(target) - call a:target.activate({'where': 't'}) -endfunction - -" FUNCTION: s:openInNewTabSilent(target) {{{2 -function! s:openInNewTabSilent(target) - call a:target.activate({'where': 't', 'stay': 1}) -endfunction - -" FUNCTION: s:openNodeRecursively(node) {{{2 -function! s:openNodeRecursively(node) - call nerdtree#echo("Recursively opening node. Please wait...") - call a:node.openRecursively() - call nerdtree#renderView() - redraw - call nerdtree#echo("Recursively opening node. Please wait... DONE") -endfunction - -"FUNCTION: s:previewNodeCurrent(node) {{{2 -function! s:previewNodeCurrent(node) - call a:node.open({'stay': 1, 'where': 'p', 'keepopen': 1}) -endfunction - -"FUNCTION: s:previewNodeHSplit(node) {{{2 -function! s:previewNodeHSplit(node) - call a:node.open({'stay': 1, 'where': 'h', 'keepopen': 1}) -endfunction - -"FUNCTION: s:previewNodeVSplit(node) {{{2 -function! s:previewNodeVSplit(node) - call a:node.open({'stay': 1, 'where': 'v', 'keepopen': 1}) -endfunction - -" FUNCTION: nerdtree#revealBookmark(name) {{{2 -" put the cursor on the node associate with the given name -function! nerdtree#revealBookmark(name) - try - let targetNode = g:NERDTreeBookmark.GetNodeForName(a:name, 0) - call targetNode.putCursorHere(0, 1) - catch /^NERDTree.BookmarkNotFoundError/ - call nerdtree#echo("Bookmark isnt cached under the current root") - endtry -endfunction - -" FUNCTION: s:refreshRoot() {{{2 -" Reloads the current root. All nodes below this will be lost and the root dir -" will be reloaded. -function! s:refreshRoot() - call nerdtree#echo("Refreshing the root node. This could take a while...") - call b:NERDTreeRoot.refresh() - call nerdtree#renderView() - redraw - call nerdtree#echo("Refreshing the root node. This could take a while... DONE") -endfunction - -" FUNCTION: s:refreshCurrent(node) {{{2 -" refreshes the root for the current node -function! s:refreshCurrent(node) - let node = a:node - if !node.path.isDirectory - let node = node.parent - endif - - call nerdtree#echo("Refreshing node. This could take a while...") - call node.refresh() - call nerdtree#renderView() - redraw - call nerdtree#echo("Refreshing node. This could take a while... DONE") -endfunction - -" FUNCTION: s:showMenu(node) {{{2 -function! s:showMenu(node) - let mc = g:NERDTreeMenuController.New(g:NERDTreeMenuItem.AllEnabled()) - call mc.showMenu() -endfunction - -" FUNCTION: s:toggleIgnoreFilter() {{{2 -" toggles the use of the NERDTreeIgnore option -function! s:toggleIgnoreFilter() - let b:NERDTreeIgnoreEnabled = !b:NERDTreeIgnoreEnabled - call nerdtree#renderViewSavingPosition() - call nerdtree#centerView() -endfunction - -" FUNCTION: s:toggleShowBookmarks() {{{2 -" toggles the display of bookmarks -function! s:toggleShowBookmarks() - let b:NERDTreeShowBookmarks = !b:NERDTreeShowBookmarks - if b:NERDTreeShowBookmarks - call nerdtree#renderView() - call nerdtree#putCursorOnBookmarkTable() - else - call nerdtree#renderViewSavingPosition() - endif - call nerdtree#centerView() -endfunction - -" FUNCTION: s:toggleShowFiles() {{{2 -" toggles the display of hidden files -function! s:toggleShowFiles() - let b:NERDTreeShowFiles = !b:NERDTreeShowFiles - call nerdtree#renderViewSavingPosition() - call nerdtree#centerView() -endfunction - -" FUNCTION: s:toggleShowHidden() {{{2 -" toggles the display of hidden files -function! s:toggleShowHidden() - let b:NERDTreeShowHidden = !b:NERDTreeShowHidden - call nerdtree#renderViewSavingPosition() - call nerdtree#centerView() -endfunction - -" FUNCTION: s:toggleZoom() {{{2 -" zoom (maximize/minimize) the NERDTree window -function! s:toggleZoom() - if exists("b:NERDTreeZoomed") && b:NERDTreeZoomed - let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize - exec "silent vertical resize ". size - let b:NERDTreeZoomed = 0 - else - exec "vertical resize" - let b:NERDTreeZoomed = 1 - endif -endfunction - -" FUNCTION: s:upDirCurrentRootOpen() {{{2 -function! s:upDirCurrentRootOpen() - call nerdtree#upDir(1) -endfunction - -" FUNCTION: s:upDirCurrentRootClosed() {{{2 -function! s:upDirCurrentRootClosed() - call nerdtree#upDir(0) -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/doc/NERD_tree.txt b/common/.vim/bundle/nerdtree/doc/NERD_tree.txt deleted file mode 100644 index 47f3472..0000000 --- a/common/.vim/bundle/nerdtree/doc/NERD_tree.txt +++ /dev/null @@ -1,1362 +0,0 @@ -*NERD_tree.txt* A tree explorer plugin that owns your momma! - - - - omg its ... ~ - - ________ ________ _ ____________ ____ __________ ____________~ - /_ __/ / / / ____/ / | / / ____/ __ \/ __ \ /_ __/ __ \/ ____/ ____/~ - / / / /_/ / __/ / |/ / __/ / /_/ / / / / / / / /_/ / __/ / __/ ~ - / / / __ / /___ / /| / /___/ _, _/ /_/ / / / / _, _/ /___/ /___ ~ - /_/ /_/ /_/_____/ /_/ |_/_____/_/ |_/_____/ /_/ /_/ |_/_____/_____/ ~ - - - Reference Manual~ - - - - -============================================================================== -CONTENTS *NERDTree-contents* - - 1.Intro...................................|NERDTree| - 2.Functionality provided..................|NERDTreeFunctionality| - 2.1.Global commands...................|NERDTreeGlobalCommands| - 2.2.Bookmarks.........................|NERDTreeBookmarks| - 2.2.1.The bookmark table..........|NERDTreeBookmarkTable| - 2.2.2.Bookmark commands...........|NERDTreeBookmarkCommands| - 2.2.3.Invalid bookmarks...........|NERDTreeInvalidBookmarks| - 2.3.NERD tree mappings................|NERDTreeMappings| - 2.4.The NERD tree menu................|NERDTreeMenu| - 3.Options.................................|NERDTreeOptions| - 3.1.Option summary....................|NERDTreeOptionSummary| - 3.2.Option details....................|NERDTreeOptionDetails| - 4.The NERD tree API.......................|NERDTreeAPI| - 4.1.Key map API.......................|NERDTreeKeymapAPI| - 4.2.Menu API..........................|NERDTreeMenuAPI| - 5.About...................................|NERDTreeAbout| - 6.Changelog...............................|NERDTreeChangelog| - 7.Credits.................................|NERDTreeCredits| - 8.License.................................|NERDTreeLicense| - -============================================================================== -1. Intro *NERDTree* - -What is this "NERD tree"?? - -The NERD tree allows you to explore your filesystem and to open files and -directories. It presents the filesystem to you in the form of a tree which you -manipulate with the keyboard and/or mouse. It also allows you to perform -simple filesystem operations. - -The following features and functionality are provided by the NERD tree: - * Files and directories are displayed in a hierarchical tree structure - * Different highlighting is provided for the following types of nodes: - * files - * directories - * sym-links - * windows .lnk files - * read-only files - * executable files - * Many (customisable) mappings are provided to manipulate the tree: - * Mappings to open/close/explore directory nodes - * Mappings to open files in new/existing windows/tabs - * Mappings to change the current root of the tree - * Mappings to navigate around the tree - * ... - * Directories and files can be bookmarked. - * Most NERD tree navigation can also be done with the mouse - * Filtering of tree content (can be toggled at runtime) - * custom file filters to prevent e.g. vim backup files being displayed - * optional displaying of hidden files (. files) - * files can be "turned off" so that only directories are displayed - * The position and size of the NERD tree window can be customised - * The order in which the nodes in the tree are listed can be customised. - * A model of your filesystem is created/maintained as you explore it. This - has several advantages: - * All filesystem information is cached and is only re-read on demand - * If you revisit a part of the tree that you left earlier in your - session, the directory nodes will be opened/closed as you left them - * The script remembers the cursor position and window position in the NERD - tree so you can toggle it off (or just close the tree window) and then - reopen it (with NERDTreeToggle) the NERD tree window will appear exactly - as you left it - * You can have a separate NERD tree for each tab, share trees across tabs, - or a mix of both. - * By default the script overrides the default file browser (netw), so if - you :edit a directory a (slighly modified) NERD tree will appear in the - current window - * A programmable menu system is provided (simulates right clicking on a - node) - * one default menu plugin is provided to perform basic filesytem - operations (create/delete/move/copy files/directories) - * There's an API for adding your own keymappings - - -============================================================================== -2. Functionality provided *NERDTreeFunctionality* - ------------------------------------------------------------------------------- -2.1. Global Commands *NERDTreeGlobalCommands* - -:NERDTree [ | ] *:NERDTree* - Opens a fresh NERD tree. The root of the tree depends on the argument - given. There are 3 cases: If no argument is given, the current directory - will be used. If a directory is given, that will be used. If a bookmark - name is given, the corresponding directory will be used. For example: > - :NERDTree /home/marty/vim7/src - :NERDTree foo (foo is the name of a bookmark) -< -:NERDTreeFromBookmark *:NERDTreeFromBookmark* - Opens a fresh NERD tree with the root initialized to the dir for - . This only reason to use this command over :NERDTree is for - the completion (which is for bookmarks rather than directories). - -:NERDTreeToggle [ | ] *:NERDTreeToggle* - If a NERD tree already exists for this tab, it is reopened and rendered - again. If no NERD tree exists for this tab then this command acts the - same as the |:NERDTree| command. - -:NERDTreeMirror *:NERDTreeMirror* - Shares an existing NERD tree, from another tab, in the current tab. - Changes made to one tree are reflected in both as they are actually the - same buffer. - - If only one other NERD tree exists, that tree is automatically mirrored. If - more than one exists, the script will ask which tree to mirror. - -:NERDTreeClose *:NERDTreeClose* - Close the NERD tree in this tab. - -:NERDTreeFind *:NERDTreeFind* - Find the current file in the tree. - - If not tree exists and the current file is under vim's CWD, then init a - tree at the CWD and reveal the file. Otherwise init a tree in the current - file's directory. - - In any case, the current file is revealed and the cursor is placed on it. - -:NERDTreeCWD *:NERDTreeCWD* - Change tree root to current directory. If no NERD tree exists for this - tab, a new tree will be opened. - ------------------------------------------------------------------------------- -2.2. Bookmarks *NERDTreeBookmarks* - -Bookmarks in the NERD tree are a way to tag files or directories of interest. -For example, you could use bookmarks to tag all of your project directories. - ------------------------------------------------------------------------------- -2.2.1. The Bookmark Table *NERDTreeBookmarkTable* - -If the bookmark table is active (see |NERDTree-B| and -|'NERDTreeShowBookmarks'|), it will be rendered above the tree. You can double -click bookmarks or use the |NERDTree-o| mapping to activate them. See also, -|NERDTree-t| and |NERDTree-T| - ------------------------------------------------------------------------------- -2.2.2. Bookmark commands *NERDTreeBookmarkCommands* - -Note that the following commands are only available in the NERD tree buffer. - -:Bookmark - Bookmark the current node as . If there is already a - bookmark, it is overwritten. must not contain spaces. - If is not provided, it defaults to the file or directory name. - For directories, a trailing slash is present. - -:BookmarkToRoot - Make the directory corresponding to the new root. If a treenode - corresponding to is already cached somewhere in the tree then - the current tree will be used, otherwise a fresh tree will be opened. - Note that if points to a file then its parent will be used - instead. - -:RevealBookmark - If the node is cached under the current root then it will be revealed - (i.e. directory nodes above it will be opened) and the cursor will be - placed on it. - -:OpenBookmark - must point to a file. The file is opened as though |NERDTree-o| - was applied. If the node is cached under the current root then it will be - revealed and the cursor will be placed on it. - -:ClearBookmarks [] - Remove all the given bookmarks. If no bookmarks are given then remove all - bookmarks on the current node. - -:ClearAllBookmarks - Remove all bookmarks. - -:ReadBookmarks - Re-read the bookmarks in the |'NERDTreeBookmarksFile'|. - -See also |:NERDTree| and |:NERDTreeFromBookmark|. - ------------------------------------------------------------------------------- -2.2.3. Invalid Bookmarks *NERDTreeInvalidBookmarks* - -If invalid bookmarks are detected, the script will issue an error message and -the invalid bookmarks will become unavailable for use. - -These bookmarks will still be stored in the bookmarks file (see -|'NERDTreeBookmarksFile'|), down the bottom. There will always be a blank line -after the valid bookmarks but before the invalid ones. - -Each line in the bookmarks file represents one bookmark. The proper format is: - - -After you have corrected any invalid bookmarks, either restart vim, or go -:ReadBookmarks from the NERD tree window. - ------------------------------------------------------------------------------- -2.3. NERD tree Mappings *NERDTreeMappings* - -Default Description~ help-tag~ -Key~ - -o.......Open files, directories and bookmarks....................|NERDTree-o| -go......Open selected file, but leave cursor in the NERDTree.....|NERDTree-go| -t.......Open selected node/bookmark in a new tab.................|NERDTree-t| -T.......Same as 't' but keep the focus on the current tab........|NERDTree-T| -i.......Open selected file in a split window.....................|NERDTree-i| -gi......Same as i, but leave the cursor on the NERDTree..........|NERDTree-gi| -s.......Open selected file in a new vsplit.......................|NERDTree-s| -gs......Same as s, but leave the cursor on the NERDTree..........|NERDTree-gs| -O.......Recursively open the selected directory..................|NERDTree-O| -x.......Close the current nodes parent...........................|NERDTree-x| -X.......Recursively close all children of the current node.......|NERDTree-X| -e.......Edit the current dif.....................................|NERDTree-e| - -...............same as |NERDTree-o|. -double-click.......same as the |NERDTree-o| map. -middle-click.......same as |NERDTree-i| for files, same as - |NERDTree-e| for dirs. - -D.......Delete the current bookmark .............................|NERDTree-D| - -P.......Jump to the root node....................................|NERDTree-P| -p.......Jump to current nodes parent.............................|NERDTree-p| -K.......Jump up inside directories at the current tree depth.....|NERDTree-K| -J.......Jump down inside directories at the current tree depth...|NERDTree-J| -...Jump down to the next sibling of the current directory...|NERDTree-C-J| -...Jump up to the previous sibling of the current directory.|NERDTree-C-K| - -C.......Change the tree root to the selected dir.................|NERDTree-C| -u.......Move the tree root up one directory......................|NERDTree-u| -U.......Same as 'u' except the old root node is left open........|NERDTree-U| -r.......Recursively refresh the current directory................|NERDTree-r| -R.......Recursively refresh the current root.....................|NERDTree-R| -m.......Display the NERD tree menu...............................|NERDTree-m| -cd......Change the CWD to the dir of the selected node...........|NERDTree-cd| -CD......Change tree root to the CWD..............................|NERDTree-CD| - -I.......Toggle whether hidden files displayed....................|NERDTree-I| -f.......Toggle whether the file filters are used.................|NERDTree-f| -F.......Toggle whether files are displayed.......................|NERDTree-F| -B.......Toggle whether the bookmark table is displayed...........|NERDTree-B| - -q.......Close the NERDTree window................................|NERDTree-q| -A.......Zoom (maximize/minimize) the NERDTree window.............|NERDTree-A| -?.......Toggle the display of the quick help.....................|NERDTree-?| - ------------------------------------------------------------------------------- - *NERDTree-o* -Default key: o -Map option: NERDTreeMapActivateNode -Applies to: files and directories. - -If a file node is selected, it is opened in the previous window. - -If a directory is selected it is opened or closed depending on its current -state. - -If a bookmark that links to a directory is selected then that directory -becomes the new root. - -If a bookmark that links to a file is selected then that file is opened in the -previous window. - ------------------------------------------------------------------------------- - *NERDTree-go* -Default key: go -Map option: None -Applies to: files. - -If a file node is selected, it is opened in the previous window, but the -cursor does not move. - -The key combo for this mapping is always "g" + NERDTreeMapActivateNode (see -|NERDTree-o|). - ------------------------------------------------------------------------------- - *NERDTree-t* -Default key: t -Map option: NERDTreeMapOpenInTab -Applies to: files and directories. - -Opens the selected file in a new tab. If a directory is selected, a fresh -NERD Tree for that directory is opened in a new tab. - -If a bookmark which points to a directory is selected, open a NERD tree for -that directory in a new tab. If the bookmark points to a file, open that file -in a new tab. - ------------------------------------------------------------------------------- - *NERDTree-T* -Default key: T -Map option: NERDTreeMapOpenInTabSilent -Applies to: files and directories. - -The same as |NERDTree-t| except that the focus is kept in the current tab. - ------------------------------------------------------------------------------- - *NERDTree-i* -Default key: i -Map option: NERDTreeMapOpenSplit -Applies to: files. - -Opens the selected file in a new split window and puts the cursor in the new -window. - ------------------------------------------------------------------------------- - *NERDTree-gi* -Default key: gi -Map option: None -Applies to: files. - -The same as |NERDTree-i| except that the cursor is not moved. - -The key combo for this mapping is always "g" + NERDTreeMapOpenSplit (see -|NERDTree-i|). - ------------------------------------------------------------------------------- - *NERDTree-s* -Default key: s -Map option: NERDTreeMapOpenVSplit -Applies to: files. - -Opens the selected file in a new vertically split window and puts the cursor in -the new window. - ------------------------------------------------------------------------------- - *NERDTree-gs* -Default key: gs -Map option: None -Applies to: files. - -The same as |NERDTree-s| except that the cursor is not moved. - -The key combo for this mapping is always "g" + NERDTreeMapOpenVSplit (see -|NERDTree-s|). - ------------------------------------------------------------------------------- - *NERDTree-O* -Default key: O -Map option: NERDTreeMapOpenRecursively -Applies to: directories. - -Recursively opens the selelected directory. - -All files and directories are cached, but if a directory would not be -displayed due to file filters (see |'NERDTreeIgnore'| |NERDTree-f|) or the -hidden file filter (see |'NERDTreeShowHidden'|) then its contents are not -cached. This is handy, especially if you have .svn directories. - ------------------------------------------------------------------------------- - *NERDTree-x* -Default key: x -Map option: NERDTreeMapCloseDir -Applies to: files and directories. - -Closes the parent of the selected node. - ------------------------------------------------------------------------------- - *NERDTree-X* -Default key: X -Map option: NERDTreeMapCloseChildren -Applies to: directories. - -Recursively closes all children of the selected directory. - -Tip: To quickly "reset" the tree, use |NERDTree-P| with this mapping. - ------------------------------------------------------------------------------- - *NERDTree-e* -Default key: e -Map option: NERDTreeMapOpenExpl -Applies to: files and directories. - -|:edit|s the selected directory, or the selected file's directory. This could -result in a NERD tree or a netrw being opened, depending on -|'NERDTreeHijackNetrw'|. - ------------------------------------------------------------------------------- - *NERDTree-D* -Default key: D -Map option: NERDTreeMapDeleteBookmark -Applies to: lines in the bookmarks table - -Deletes the currently selected bookmark. - ------------------------------------------------------------------------------- - *NERDTree-P* -Default key: P -Map option: NERDTreeMapJumpRoot -Applies to: no restrictions. - -Jump to the tree root. - ------------------------------------------------------------------------------- - *NERDTree-p* -Default key: p -Map option: NERDTreeMapJumpParent -Applies to: files and directories. - -Jump to the parent node of the selected node. - ------------------------------------------------------------------------------- - *NERDTree-K* -Default key: K -Map option: NERDTreeMapJumpFirstChild -Applies to: files and directories. - -Jump to the first child of the current nodes parent. - -If the cursor is already on the first node then do the following: - * loop back thru the siblings of the current nodes parent until we find an - open dir with children - * go to the first child of that node - ------------------------------------------------------------------------------- - *NERDTree-J* -Default key: J -Map option: NERDTreeMapJumpLastChild -Applies to: files and directories. - -Jump to the last child of the current nodes parent. - -If the cursor is already on the last node then do the following: - * loop forward thru the siblings of the current nodes parent until we find - an open dir with children - * go to the last child of that node - ------------------------------------------------------------------------------- - *NERDTree-C-J* -Default key: -Map option: NERDTreeMapJumpNextSibling -Applies to: files and directories. - -Jump to the next sibling of the selected node. - ------------------------------------------------------------------------------- - *NERDTree-C-K* -Default key: -Map option: NERDTreeMapJumpPrevSibling -Applies to: files and directories. - -Jump to the previous sibling of the selected node. - ------------------------------------------------------------------------------- - *NERDTree-C* -Default key: C -Map option: NERDTreeMapChdir -Applies to: directories. - -Make the selected directory node the new tree root. If a file is selected, its -parent is used. - ------------------------------------------------------------------------------- - *NERDTree-u* -Default key: u -Map option: NERDTreeMapUpdir -Applies to: no restrictions. - -Move the tree root up a dir (like doing a "cd .."). - ------------------------------------------------------------------------------- - *NERDTree-U* -Default key: U -Map option: NERDTreeMapUpdirKeepOpen -Applies to: no restrictions. - -Like |NERDTree-u| except that the old tree root is kept open. - ------------------------------------------------------------------------------- - *NERDTree-r* -Default key: r -Map option: NERDTreeMapRefresh -Applies to: files and directories. - -If a dir is selected, recursively refresh that dir, i.e. scan the filesystem -for changes and represent them in the tree. - -If a file node is selected then the above is done on it's parent. - ------------------------------------------------------------------------------- - *NERDTree-R* -Default key: R -Map option: NERDTreeMapRefreshRoot -Applies to: no restrictions. - -Recursively refresh the tree root. - ------------------------------------------------------------------------------- - *NERDTree-m* -Default key: m -Map option: NERDTreeMapMenu -Applies to: files and directories. - -Display the NERD tree menu. See |NERDTreeMenu| for details. - ------------------------------------------------------------------------------- - *NERDTree-cd* -Default key: cd -Map option: NERDTreeMapChdir -Applies to: files and directories. - -Change vims current working directory to that of the selected node. - ------------------------------------------------------------------------------- - *NERDTree-CD* -Default key: CD -Map option: NERDTreeMapCWD -Applies to: no restrictions. - -Change tree root to vims current working directory. - ------------------------------------------------------------------------------- - *NERDTree-I* -Default key: I -Map option: NERDTreeMapToggleHidden -Applies to: no restrictions. - -Toggles whether hidden files (i.e. "dot files") are displayed. - ------------------------------------------------------------------------------- - *NERDTree-f* -Default key: f -Map option: NERDTreeMapToggleFilters -Applies to: no restrictions. - -Toggles whether file filters are used. See |'NERDTreeIgnore'| for details. - ------------------------------------------------------------------------------- - *NERDTree-F* -Default key: F -Map option: NERDTreeMapToggleFiles -Applies to: no restrictions. - -Toggles whether file nodes are displayed. - ------------------------------------------------------------------------------- - *NERDTree-B* -Default key: B -Map option: NERDTreeMapToggleBookmarks -Applies to: no restrictions. - -Toggles whether the bookmarks table is displayed. - ------------------------------------------------------------------------------- - *NERDTree-q* -Default key: q -Map option: NERDTreeMapQuit -Applies to: no restrictions. - -Closes the NERDtree window. - ------------------------------------------------------------------------------- - *NERDTree-A* -Default key: A -Map option: NERDTreeMapToggleZoom -Applies to: no restrictions. - -Maximize (zoom) and minimize the NERDtree window. - ------------------------------------------------------------------------------- - *NERDTree-?* -Default key: ? -Map option: NERDTreeMapHelp -Applies to: no restrictions. - -Toggles whether the quickhelp is displayed. - ------------------------------------------------------------------------------- -2.3. The NERD tree menu *NERDTreeMenu* - -The NERD tree has a menu that can be programmed via the an API (see -|NERDTreeMenuAPI|). The idea is to simulate the "right click" menus that most -file explorers have. - -The script comes with two default menu plugins: exec_menuitem.vim and -fs_menu.vim. fs_menu.vim adds some basic filesystem operations to the menu for -creating/deleting/moving/copying files and dirs. exec_menuitem.vim provides a -menu item to execute executable files. - -Related tags: |NERDTree-m| |NERDTreeApi| - -============================================================================== -3. Customisation *NERDTreeOptions* - - ------------------------------------------------------------------------------- -3.1. Customisation summary *NERDTreeOptionSummary* - -The script provides the following options that can customise the behaviour the -NERD tree. These options should be set in your vimrc. - -|'loaded_nerd_tree'| Turns off the script. - -|'NERDChristmasTree'| Tells the NERD tree to make itself colourful - and pretty. - -|'NERDTreeAutoCenter'| Controls whether the NERD tree window centers - when the cursor moves within a specified - distance to the top/bottom of the window. -|'NERDTreeAutoCenterThreshold'| Controls the sensitivity of autocentering. - -|'NERDTreeCaseSensitiveSort'| Tells the NERD tree whether to be case - sensitive or not when sorting nodes. - -|'NERDTreeChDirMode'| Tells the NERD tree if/when it should change - vim's current working directory. - -|'NERDTreeHighlightCursorline'| Tell the NERD tree whether to highlight the - current cursor line. - -|'NERDTreeHijackNetrw'| Tell the NERD tree whether to replace the netrw - autocommands for exploring local directories. - -|'NERDTreeIgnore'| Tells the NERD tree which files to ignore. - -|'NERDTreeBookmarksFile'| Where the bookmarks are stored. - -|'NERDTreeMouseMode'| Tells the NERD tree how to handle mouse - clicks. - -|'NERDTreeQuitOnOpen'| Closes the tree window after opening a file. - -|'NERDTreeShowBookmarks'| Tells the NERD tree whether to display the - bookmarks table on startup. - -|'NERDTreeShowFiles'| Tells the NERD tree whether to display files - in the tree on startup. - -|'NERDTreeShowHidden'| Tells the NERD tree whether to display hidden - files on startup. - -|'NERDTreeShowLineNumbers'| Tells the NERD tree whether to display line - numbers in the tree window. - -|'NERDTreeSortOrder'| Tell the NERD tree how to sort the nodes in - the tree. - -|'NERDTreeStatusline'| Set a statusline for NERD tree windows. - -|'NERDTreeWinPos'| Tells the script where to put the NERD tree - window. - -|'NERDTreeWinSize'| Sets the window size when the NERD tree is - opened. - -|'NERDTreeMinimalUI'| Disables display of the 'Bookmarks' label and - 'Press ? for help' text. - -|'NERDTreeDirArrows'| Tells the NERD tree to use arrows instead of - + ~ chars when displaying directories. - -|'NERDTreeCasadeOpenSingleChildDir'| - Casade open while selected directory has only - one child that also is a directory. - -|'NERDTreeAutoDeleteBuffer'| Tells the NERD tree to automatically remove - a buffer when a file is being deleted or renamed - via a context menu command. - ------------------------------------------------------------------------------- -3.2. Customisation details *NERDTreeOptionDetails* - -To enable any of the below options you should put the given line in your -~/.vimrc - - *'loaded_nerd_tree'* -If this plugin is making you feel homicidal, it may be a good idea to turn it -off with this line in your vimrc: > - let loaded_nerd_tree=1 -< ------------------------------------------------------------------------------- - *'NERDChristmasTree'* -Values: 0 or 1. -Default: 1. - -If this option is set to 1 then some extra syntax highlighting elements are -added to the nerd tree to make it more colourful. - -Set it to 0 for a more vanilla looking tree. - ------------------------------------------------------------------------------- - *'NERDTreeAutoCenter'* -Values: 0 or 1. -Default: 1 - -If set to 1, the NERD tree window will center around the cursor if it moves to -within |'NERDTreeAutoCenterThreshold'| lines of the top/bottom of the window. - -This is ONLY done in response to tree navigation mappings, -i.e. |NERDTree-J| |NERDTree-K| |NERDTree-C-J| |NERDTree-C-K| |NERDTree-p| -|NERDTree-P| - -The centering is done with a |zz| operation. - ------------------------------------------------------------------------------- - *'NERDTreeAutoCenterThreshold'* -Values: Any natural number. -Default: 3 - -This option controls the "sensitivity" of the NERD tree auto centering. See -|'NERDTreeAutoCenter'| for details. - ------------------------------------------------------------------------------- - *'NERDTreeCaseSensitiveSort'* -Values: 0 or 1. -Default: 0. - -By default the NERD tree does not sort nodes case sensitively, i.e. nodes -could appear like this: > - bar.c - Baz.c - blarg.c - boner.c - Foo.c -< -But, if you set this option to 1 then the case of the nodes will be taken into -account. The above nodes would then be sorted like this: > - Baz.c - Foo.c - bar.c - blarg.c - boner.c -< ------------------------------------------------------------------------------- - *'NERDTreeChDirMode'* - -Values: 0, 1 or 2. -Default: 0. - -Use this option to tell the script when (if at all) to change the current -working directory (CWD) for vim. - -If it is set to 0 then the CWD is never changed by the NERD tree. - -If set to 1 then the CWD is changed when the NERD tree is first loaded to the -directory it is initialized in. For example, if you start the NERD tree with > - :NERDTree /home/marty/foobar -< -then the CWD will be changed to /home/marty/foobar and will not be changed -again unless you init another NERD tree with a similar command. - -If the option is set to 2 then it behaves the same as if set to 1 except that -the CWD is changed whenever the tree root is changed. For example, if the CWD -is /home/marty/foobar and you make the node for /home/marty/foobar/baz the new -root then the CWD will become /home/marty/foobar/baz. - ------------------------------------------------------------------------------- - *'NERDTreeHighlightCursorline'* -Values: 0 or 1. -Default: 1. - -If set to 1, the current cursor line in the NERD tree buffer will be -highlighted. This is done using the |'cursorline'| option. - ------------------------------------------------------------------------------- - *'NERDTreeHijackNetrw'* -Values: 0 or 1. -Default: 1. - -If set to 1, doing a > - :edit -< -will open up a "secondary" NERD tree instead of a netrw in the target window. - -Secondary NERD trees behaves slighly different from a regular trees in the -following respects: - 1. 'o' will open the selected file in the same window as the tree, - replacing it. - 2. you can have as many secondary tree as you want in the same tab. - ------------------------------------------------------------------------------- - *'NERDTreeIgnore'* -Values: a list of regular expressions. -Default: ['\~$']. - -This option is used to specify which files the NERD tree should ignore. It -must be a list of regular expressions. When the NERD tree is rendered, any -files/dirs that match any of the regex's in 'NERDTreeIgnore' wont be -displayed. - -For example if you put the following line in your vimrc: > - let NERDTreeIgnore=['\.vim$', '\~$'] -< -then all files ending in .vim or ~ will be ignored. - -There are 2 magic flags that can be appended to the end of each regular -expression to specify that the regex should match only files or only dirs. -These flags are "[[dir]]" and "[[file]]". Example: > - let NERDTreeIgnore=['.d$[[dir]]', '.o$[[file]]'] -< -This will cause all dirs ending in ".d" to be ignored and all files ending in -".o" to be ignored. - -Note: to tell the NERD tree not to ignore any files you must use the following -line: > - let NERDTreeIgnore=[] -< - -The file filters can be turned on and off dynamically with the |NERDTree-f| -mapping. - ------------------------------------------------------------------------------- - *'NERDTreeBookmarksFile'* -Values: a path -Default: $HOME/.NERDTreeBookmarks - -This is where bookmarks are saved. See |NERDTreeBookmarkCommands|. - ------------------------------------------------------------------------------- - *'NERDTreeMouseMode'* -Values: 1, 2 or 3. -Default: 1. - -If set to 1 then a double click on a node is required to open it. -If set to 2 then a single click will open directory nodes, while a double -click will still be required for file nodes. -If set to 3 then a single click will open any node. - -Note: a double click anywhere on a line that a tree node is on will -activate it, but all single-click activations must be done on name of the node -itself. For example, if you have the following node: > - | | |-application.rb -< -then (to single click activate it) you must click somewhere in -'application.rb'. - ------------------------------------------------------------------------------- - *'NERDTreeQuitOnOpen'* - -Values: 0 or 1. -Default: 0 - -If set to 1, the NERD tree window will close after opening a file with the -|NERDTree-o|, |NERDTree-i|, |NERDTree-t| and |NERDTree-T| mappings. - ------------------------------------------------------------------------------- - *'NERDTreeShowBookmarks'* -Values: 0 or 1. -Default: 0. - -If this option is set to 1 then the bookmarks table will be displayed. - -This option can be toggled dynamically, per tree, with the |NERDTree-B| -mapping. - ------------------------------------------------------------------------------- - *'NERDTreeShowFiles'* -Values: 0 or 1. -Default: 1. - -If this option is set to 1 then files are displayed in the NERD tree. If it is -set to 0 then only directories are displayed. - -This option can be toggled dynamically, per tree, with the |NERDTree-F| -mapping and is useful for drastically shrinking the tree when you are -navigating to a different part of the tree. - ------------------------------------------------------------------------------- - *'NERDTreeShowHidden'* -Values: 0 or 1. -Default: 0. - -This option tells vim whether to display hidden files by default. This option -can be dynamically toggled, per tree, with the |NERDTree-I| mapping. Use one -of the follow lines to set this option: > - let NERDTreeShowHidden=0 - let NERDTreeShowHidden=1 -< - ------------------------------------------------------------------------------- - *'NERDTreeShowLineNumbers'* -Values: 0 or 1. -Default: 0. - -This option tells vim whether to display line numbers for the NERD tree -window. Use one of the follow lines to set this option: > - let NERDTreeShowLineNumbers=0 - let NERDTreeShowLineNumbers=1 -< - ------------------------------------------------------------------------------- - *'NERDTreeSortOrder'* -Values: a list of regular expressions. -Default: ['\/$', '*', '\.swp$', '\.bak$', '\~$'] - -This option is set to a list of regular expressions which are used to -specify the order of nodes under their parent. - -For example, if the option is set to: > - ['\.vim$', '\.c$', '\.h$', '*', 'foobar'] -< -then all .vim files will be placed at the top, followed by all .c files then -all .h files. All files containing the string 'foobar' will be placed at the -end. The star is a special flag: it tells the script that every node that -doesnt match any of the other regexps should be placed here. - -If no star is present in 'NERDTreeSortOrder' then one is automatically -appended to the array. - -The regex '\/$' should be used to match directory nodes. - -After this sorting is done, the files in each group are sorted alphabetically. - -Other examples: > - (1) ['*', '\/$'] - (2) [] - (3) ['\/$', '\.rb$', '\.php$', '*', '\.swp$', '\.bak$', '\~$'] -< -1. Directories will appear last, everything else will appear above. -2. Everything will simply appear in alphabetical order. -3. Dirs will appear first, then ruby and php. Swap files, bak files and vim - backup files will appear last with everything else preceding them. - ------------------------------------------------------------------------------- - *'NERDTreeStatusline'* -Values: Any valid statusline setting. -Default: %{b:NERDTreeRoot.path.strForOS(0)} - -Tells the script what to use as the |'statusline'| setting for NERD tree -windows. - -Note that the statusline is set using |:let-&| not |:set| so escaping spaces -isn't necessary. - -Setting this option to -1 will will deactivate it so that your global -statusline setting is used instead. - ------------------------------------------------------------------------------- - *'NERDTreeWinPos'* -Values: "left" or "right" -Default: "left". - -This option is used to determine where NERD tree window is placed on the -screen. - -This option makes it possible to use two different explorer plugins -simultaneously. For example, you could have the taglist plugin on the left of -the window and the NERD tree on the right. - ------------------------------------------------------------------------------- - *'NERDTreeWinSize'* -Values: a positive integer. -Default: 31. - -This option is used to change the size of the NERD tree when it is loaded. - ------------------------------------------------------------------------------- - *'NERDTreeMinimalUI'* -Values: 0 or 1 -Default: 0 - -This options disables the 'Bookmarks' label 'Press ? for help' text. Use one -of the following lines to set this option: > - let NERDTreeMinimalUI=0 - let NERDTreeMinimalUI=1 -< - ------------------------------------------------------------------------------- - *'NERDTreeDirArrows'* -Values: 0 or 1 -Default: 0. - -This option is used to change the default look of directory nodes displayed in -the tree. When set to 0 it shows old-school bars (|), + and ~ chars. If set to -1 it shows right and down arrows. Use one of the follow lines to set this -option: > - let NERDTreeDirArrows=0 - let NERDTreeDirArrows=1 -< - ------------------------------------------------------------------------------- - *'NERDTreeCasadeOpenSingleChildDir'* -Values: 0 or 1 -Default: 1. - -When opening dir nodes, this option tells NERDTree to recursively open dirs -that have only one child which is also a dir. NERDTree will stop when it finds -a dir that contains anything but another single dir. This option may be useful -for Java projects. Use one of the follow lines to set this option: > - let NERDTreeCasadeOpenSingleChildDir=0 - let NERDTreeCasadeOpenSingleChildDir=1 -< - ------------------------------------------------------------------------------- - *'NERDTreeAutoDeleteBuffer'* -Values: 0 or 1 -Default: 0. - -When using a context menu to delete or rename a file you may also want to delete -the buffer which is no more valid. If the option is not set you will see a -confirmation if you really want to delete an old buffer. If you always press 'y' -then it worths to set this option to 1. Use one of the follow lines to set this -option: > - let NERDTreeAutoDeleteBuffer=0 - let NERDTreeAutoDeleteBuffer=1 -< - -============================================================================== -4. The NERD tree API *NERDTreeAPI* - -The NERD tree script allows you to add custom key mappings and menu items via -a set of API calls. Any scripts that use this API should be placed in -~/.vim/nerdtree_plugin/ (*nix) or ~/vimfiles/nerdtree_plugin (windows). - -The script exposes some prototype objects that can be used to manipulate the -tree and/or get information from it: > - g:NERDTreePath - g:NERDTreeDirNode - g:NERDTreeFileNode - g:NERDTreeBookmark -< -See the code/comments in NERD_tree.vim to find how to use these objects. The -following code conventions are used: - * class members start with a capital letter - * instance members start with a lower case letter - * private members start with an underscore - -See this blog post for more details: - http://got-ravings.blogspot.com/2008/09/vim-pr0n-prototype-based-objects.html - ------------------------------------------------------------------------------- -4.1. Key map API *NERDTreeKeymapAPI* - -NERDTreeAddKeyMap({options}) *NERDTreeAddKeyMap()* - Adds a new keymapping for all NERD tree buffers. - {options} must be a dictionary, and must contain the following keys: - "key" - the trigger key for the new mapping - "callback" - the function the new mapping will be bound to - "quickhelpText" - the text that will appear in the quickhelp (see - |NERDTree-?|) - - Additionally, a "scope" argument may be supplied. This constrains the - mapping so that it is only activated if the cursor is on a certain object. - That object is then passed into the handling method. Possible values are: - "FileNode" - a file node - "DirNode" - a directory node - "Node" - a file or directory node - "Bookmark" - A bookmark - "all" - the keymap is not constrained to any scope (default). When - thei is used, the handling function is not passed any arguments. - - - Example: > - call NERDTreeAddKeyMap({ - \ 'key': 'foo', - \ 'callback': 'NERDTreeCDHandler', - \ 'quickhelpText': 'echo full path of current node' }) - \ 'scope': 'DirNode' - - function! NERDTreeCDHandler(dirnode) - call a:dirnode.changeToDir() - endfunction -< - This code should sit in a file like ~/.vim/nerdtree_plugin/mymapping.vim. - It adds a (redundant) mapping on 'foo' which changes vim's CWD to that of - the current dir node. Note this mapping will only fire when the cursor is - on a directory node. - ------------------------------------------------------------------------------- -4.2. Menu API *NERDTreeMenuAPI* - -NERDTreeAddSubmenu({options}) *NERDTreeAddSubmenu()* - Creates and returns a new submenu. - - {options} must be a dictionary and must contain the following keys: - "text" - the text of the submenu that the user will see - "shortcut" - a shortcut key for the submenu (need not be unique) - - The following keys are optional: - "isActiveCallback" - a function that will be called to determine whether - this submenu item will be displayed or not. The callback function must return - 0 or 1. - "parent" - the parent submenu of the new submenu (returned from a previous - invocation of NERDTreeAddSubmenu()). If this key is left out then the new - submenu will sit under the top level menu. - - See below for an example. - -NERDTreeAddMenuItem({options}) *NERDTreeAddMenuItem()* - Adds a new menu item to the NERD tree menu (see |NERDTreeMenu|). - - {options} must be a dictionary and must contain the - following keys: - "text" - the text of the menu item which the user will see - "shortcut" - a shortcut key for the menu item (need not be unique) - "callback" - the function that will be called when the user activates the - menu item. - - The following keys are optional: - "isActiveCallback" - a function that will be called to determine whether - this menu item will be displayed or not. The callback function must return - 0 or 1. - "parent" - if the menu item belongs under a submenu then this key must be - specified. This value for this key will be the object that - was returned when the submenu was created with |NERDTreeAddSubmenu()|. - - See below for an example. - -NERDTreeAddMenuSeparator([{options}]) *NERDTreeAddMenuSeparator()* - Adds a menu separator (a row of dashes). - - {options} is an optional dictionary that may contain the following keys: - "isActiveCallback" - see description in |NERDTreeAddMenuItem()|. - -Below is an example of the menu API in action. > - call NERDTreeAddMenuSeparator() - - call NERDTreeAddMenuItem({ - \ 'text': 'a (t)op level menu item', - \ 'shortcut': 't', - \ 'callback': 'SomeFunction' }) - - let submenu = NERDTreeAddSubmenu({ - \ 'text': 'a (s)ub menu', - \ 'shortcut': 's' }) - - call NERDTreeAddMenuItem({ - \ 'text': '(n)ested item 1', - \ 'shortcut': 'n', - \ 'callback': 'SomeFunction', - \ 'parent': submenu }) - - call NERDTreeAddMenuItem({ - \ 'text': '(n)ested item 2', - \ 'shortcut': 'n', - \ 'callback': 'SomeFunction', - \ 'parent': submenu }) -< -This will create the following menu: > - -------------------- - a (t)op level menu item - a (s)ub menu -< -Where selecting "a (s)ub menu" will lead to a second menu: > - (n)ested item 1 - (n)ested item 2 -< -When any of the 3 concrete menu items are selected the function "SomeFunction" -will be called. - ------------------------------------------------------------------------------- -NERDTreeRender() *NERDTreeRender()* - Re-renders the NERD tree buffer. Useful if you change the state of the - tree and you want to it to be reflected in the UI. - -============================================================================== -5. About *NERDTreeAbout* - -The author of the NERD tree is a terrible terrible monster called Martyzilla -who gobbles up small children with milk and sugar for breakfast. - -He can be reached at martin.grenfell at gmail dot com. He would love to hear -from you, so feel free to send him suggestions and/or comments about this -plugin. Don't be shy --- the worst he can do is slaughter you and stuff you in -the fridge for later ;) - -The latest stable versions can be found at - http://www.vim.org/scripts/script.php?script_id=1658 - -The latest dev versions are on github - http://github.com/scrooloose/nerdtree - - -============================================================================== -6. Changelog *NERDTreeChangelog* - -Next - - add 'scope' argument to the key map API - - add NERDTreeCustomIgnoreFilter hook - needs doc - - add magic [[dir]] and [[file]] flags to NERDTreeIgnore - -4.2.0 - - Add NERDTreeDirArrows option to make the UI use pretty arrow chars - instead of the old +~| chars to define the tree structure (sickill) - - shift the syntax highlighting out into its own syntax file (gnap) - - add some mac specific options to the filesystem menu - for macvim - only (andersonfreitas) - - Add NERDTreeMinimalUI option to remove some non functional parts of the - nerdtree ui (camthompson) - - tweak the behaviour of :NERDTreeFind - see :help :NERDTreeFind for the - new behaviour (benjamingeiger) - - if no name is given to :Bookmark, make it default to the name of the - target file/dir (minyoung) - - use 'file' completion when doing copying, create, and move - operations (EvanDotPro) - - lots of misc bug fixes (paddyoloughlin, sdewald, camthompson, Vitaly - Bogdanov, AndrewRadev, mathias, scottstvnsn, kml, wycats, me RAWR!) - -4.1.0 - features: - - NERDTreeFind to reveal the node for the current buffer in the tree, - see |NERDTreeFind|. This effectively merges the FindInNERDTree plugin (by - Doug McInnes) into the script. - - make NERDTreeQuitOnOpen apply to the t/T keymaps too. Thanks to Stefan - Ritter and Rémi Prévost. - - truncate the root node if wider than the tree window. Thanks to Victor - Gonzalez. - - bugfixes: - - really fix window state restoring - - fix some win32 path escaping issues. Thanks to Stephan Baumeister, Ricky, - jfilip1024, and Chris Chambers - -4.0.0 - - add a new programmable menu system (see :help NERDTreeMenu). - - add new APIs to add menus/menu-items to the menu system as well as - custom key mappings to the NERD tree buffer (see :help NERDTreeAPI). - - removed the old API functions - - added a mapping to maximize/restore the size of nerd tree window, thanks - to Guillaume Duranceau for the patch. See :help NERDTree-A for details. - - - fix a bug where secondary nerd trees (netrw hijacked trees) and - NERDTreeQuitOnOpen didnt play nicely, thanks to Curtis Harvey. - - fix a bug where the script ignored directories whose name ended in a dot, - thanks to Aggelos Orfanakos for the patch. - - fix a bug when using the x mapping on the tree root, thanks to Bryan - Venteicher for the patch. - - fix a bug where the cursor position/window size of the nerd tree buffer - wasnt being stored on closing the window, thanks to Richard Hart. - - fix a bug where NERDTreeMirror would mirror the wrong tree - -3.1.1 - - fix a bug where a non-listed no-name buffer was getting created every - time the tree windows was created, thanks to Derek Wyatt and owen1 - - make behave the same as the 'o' mapping - - some helptag fixes in the doc, thanks strull - - fix a bug when using :set nohidden and opening a file where the previous - buf was modified. Thanks iElectric - - other minor fixes - -3.1.0 - New features: - - add mappings to open files in a vsplit, see :help NERDTree-s and :help - NERDTree-gs - - make the statusline for the nerd tree window default to something - hopefully more useful. See :help 'NERDTreeStatusline' - Bugfixes: - - make the hijack netrw functionality work when vim is started with "vim - " (thanks to Alf Mikula for the patch). - - fix a bug where the CWD wasnt being changed for some operations even when - NERDTreeChDirMode==2 (thanks to Lucas S. Buchala) - - add -bar to all the nerd tree :commands so they can chain with other - :commands (thanks to tpope) - - fix bugs when ignorecase was set (thanks to nach) - - fix a bug with the relative path code (thanks to nach) - - fix a bug where doing a :cd would cause :NERDTreeToggle to fail (thanks nach) - - -3.0.1 - Bugfixes: - - fix bugs with :NERDTreeToggle and :NERDTreeMirror when 'hidden - was not set - - fix a bug where :NERDTree would fail if was relative and - didnt start with a ./ or ../ Thanks to James Kanze. - - make the q mapping work with secondary (:e

    style) trees, - thanks to jamessan - - fix a bunch of small bugs with secondary trees - - More insane refactoring. - -3.0.0 - - hijack netrw so that doing an :edit will put a NERD tree in - the window rather than a netrw browser. See :help 'NERDTreeHijackNetrw' - - allow sharing of trees across tabs, see :help :NERDTreeMirror - - remove "top" and "bottom" as valid settings for NERDTreeWinPos - - change the '' mapping to 'i' - - change the 'H' mapping to 'I' - - lots of refactoring - -============================================================================== -7. Credits *NERDTreeCredits* - -Thanks to the following people for testing, bug reports, ideas etc. Without -you I probably would have got bored of the hacking the NERD tree and -just downloaded pr0n instead. - - Tim Carey-Smith (halorgium) - Vigil - Nick Brettell - Thomas Scott Urban - Terrance Cohen - Yegappan Lakshmanan - Jason Mills - Michael Geddes (frogonwheels) - Yu Jun - Michael Madsen - AOYAMA Shotaro - Zhang Weiwu - Niels Aan de Brugh - Olivier Yiptong - Zhang Shuhan - Cory Echols - Piotr Czachur - Yuan Jiang - Matan Nassau - Maxim Kim - Charlton Wang - Matt Wozniski (godlygeek) - knekk - Sean Chou - Ryan Penn - Simon Peter Nicholls - Michael Foobar - Tomasz Chomiuk - Denis Pokataev - Tim Pope (tpope) - James Kanze - James Vega (jamessan) - Frederic Chanal (nach) - Alf Mikula - Lucas S. Buchala - Curtis Harvey - Guillaume Duranceau - Richard Hart (hates) - Doug McInnes - Stefan Ritter - Rémi Prévost - Victor Gonzalez - Stephan Baumeister - Ricky - jfilip1024 - Chris Chambers - Vitaly Bogdanov - Patrick O'Loughlin (paddyoloughlin) - Cam Thompson (camthompson) - Marcin Kulik (sickill) - Steve DeWald (sdewald) - Ivan Necas (iNecas) - George Ang (gnap) - Evan Coury (EvanDotPro) - Andrew Radev (AndrewRadev) - Matt Gauger (mathias) - Scott Stevenson (scottstvnsn) - Anderson Freitas (andersonfreitas) - Kamil K. Lemański (kml) - Yehuda Katz (wycats) - Min-Young Wu (minyoung) - Benjamin Geiger (benjamingeiger) - -============================================================================== -8. License *NERDTreeLicense* - -The NERD tree is released under the wtfpl. -See http://sam.zoy.org/wtfpl/COPYING. diff --git a/common/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim b/common/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim deleted file mode 100644 index e7a7c53..0000000 --- a/common/.vim/bundle/nerdtree/nerdtree_plugin/exec_menuitem.vim +++ /dev/null @@ -1,41 +0,0 @@ -" ============================================================================ -" File: exec_menuitem.vim -" Description: plugin for NERD Tree that provides an execute file menu item -" Maintainer: Martin Grenfell -" Last Change: 22 July, 2009 -" License: This program is free software. It comes without any warranty, -" to the extent permitted by applicable law. You can redistribute -" it and/or modify it under the terms of the Do What The Fuck You -" Want To Public License, Version 2, as published by Sam Hocevar. -" See http://sam.zoy.org/wtfpl/COPYING for more details. -" -" ============================================================================ -if exists("g:loaded_nerdtree_exec_menuitem") - finish -endif -let g:loaded_nerdtree_exec_menuitem = 1 - -call NERDTreeAddMenuItem({ - \ 'text': '(!)Execute file', - \ 'shortcut': '!', - \ 'callback': 'NERDTreeExecFile', - \ 'isActiveCallback': 'NERDTreeExecFileActive' }) - -function! NERDTreeExecFileActive() - let node = g:NERDTreeFileNode.GetSelected() - return !node.path.isDirectory && node.path.isExecutable -endfunction - -function! NERDTreeExecFile() - let treenode = g:NERDTreeFileNode.GetSelected() - echo "==========================================================\n" - echo "Complete the command to execute (add arguments etc):\n" - let cmd = treenode.path.str({'escape': 1}) - let cmd = input(':!', cmd . ' ') - - if cmd != '' - exec ':!' . cmd - else - echo "Aborted" - endif -endfunction diff --git a/common/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim b/common/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim deleted file mode 100644 index 9b81ed3..0000000 --- a/common/.vim/bundle/nerdtree/nerdtree_plugin/fs_menu.vim +++ /dev/null @@ -1,262 +0,0 @@ -" ============================================================================ -" File: fs_menu.vim -" Description: plugin for the NERD Tree that provides a file system menu -" Maintainer: Martin Grenfell -" Last Change: 17 July, 2009 -" License: This program is free software. It comes without any warranty, -" to the extent permitted by applicable law. You can redistribute -" it and/or modify it under the terms of the Do What The Fuck You -" Want To Public License, Version 2, as published by Sam Hocevar. -" See http://sam.zoy.org/wtfpl/COPYING for more details. -" -" ============================================================================ -if exists("g:loaded_nerdtree_fs_menu") - finish -endif -let g:loaded_nerdtree_fs_menu = 1 - -"Automatically delete the buffer after deleting or renaming a file -if !exists("g:NERDTreeAutoDeleteBuffer") - let g:NERDTreeAutoDeleteBuffer = 0 -endif - -call NERDTreeAddMenuItem({'text': '(a)dd a childnode', 'shortcut': 'a', 'callback': 'NERDTreeAddNode'}) -call NERDTreeAddMenuItem({'text': '(m)ove the current node', 'shortcut': 'm', 'callback': 'NERDTreeMoveNode'}) -call NERDTreeAddMenuItem({'text': '(d)elete the current node', 'shortcut': 'd', 'callback': 'NERDTreeDeleteNode'}) - -if has("gui_mac") || has("gui_macvim") - call NERDTreeAddMenuItem({'text': '(r)eveal in Finder the current node', 'shortcut': 'r', 'callback': 'NERDTreeRevealInFinder'}) - call NERDTreeAddMenuItem({'text': '(o)pen the current node with system editor', 'shortcut': 'o', 'callback': 'NERDTreeExecuteFile'}) - call NERDTreeAddMenuItem({'text': '(q)uicklook the current node', 'shortcut': 'q', 'callback': 'NERDTreeQuickLook'}) -endif - -if g:NERDTreePath.CopyingSupported() - call NERDTreeAddMenuItem({'text': '(c)opy the current node', 'shortcut': 'c', 'callback': 'NERDTreeCopyNode'}) -endif - -"FUNCTION: s:echo(msg){{{1 -function! s:echo(msg) - redraw - echomsg "NERDTree: " . a:msg -endfunction - -"FUNCTION: s:echoWarning(msg){{{1 -function! s:echoWarning(msg) - echohl warningmsg - call s:echo(a:msg) - echohl normal -endfunction - -"FUNCTION: s:promptToDelBuffer(bufnum, msg){{{1 -"prints out the given msg and, if the user responds by pushing 'y' then the -"buffer with the given bufnum is deleted -" -"Args: -"bufnum: the buffer that may be deleted -"msg: a message that will be echoed to the user asking them if they wish to -" del the buffer -function! s:promptToDelBuffer(bufnum, msg) - echo a:msg - if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y' - " 1. ensure that all windows which display the just deleted filename - " now display an empty buffer (so a layout is preserved). - " Is not it better to close single tabs with this file only ? - let s:originalTabNumber = tabpagenr() - let s:originalWindowNumber = winnr() - exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':enew! ' | endif" - exec "tabnext " . s:originalTabNumber - exec s:originalWindowNumber . "wincmd w" - " 3. We don't need a previous buffer anymore - exec "bwipeout! " . a:bufnum - endif -endfunction - -"FUNCTION: s:promptToRenameBuffer(bufnum, msg){{{1 -"prints out the given msg and, if the user responds by pushing 'y' then the -"buffer with the given bufnum is replaced with a new one -" -"Args: -"bufnum: the buffer that may be deleted -"msg: a message that will be echoed to the user asking them if they wish to -" del the buffer -function! s:promptToRenameBuffer(bufnum, msg, newFileName) - echo a:msg - if g:NERDTreeAutoDeleteBuffer || nr2char(getchar()) ==# 'y' - " 1. ensure that a new buffer is loaded - exec "badd " . a:newFileName - " 2. ensure that all windows which display the just deleted filename - " display a buffer for a new filename. - let s:originalTabNumber = tabpagenr() - let s:originalWindowNumber = winnr() - exec "tabdo windo if winbufnr(0) == " . a:bufnum . " | exec ':e! " . a:newFileName . "' | endif" - exec "tabnext " . s:originalTabNumber - exec s:originalWindowNumber . "wincmd w" - " 3. We don't need a previous buffer anymore - exec "bwipeout! " . a:bufnum - endif -endfunction -"FUNCTION: NERDTreeAddNode(){{{1 -function! NERDTreeAddNode() - let curDirNode = g:NERDTreeDirNode.GetSelected() - - let newNodeName = input("Add a childnode\n". - \ "==========================================================\n". - \ "Enter the dir/file name to be created. Dirs end with a '/'\n" . - \ "", curDirNode.path.str() . g:NERDTreePath.Slash(), "file") - - if newNodeName ==# '' - call s:echo("Node Creation Aborted.") - return - endif - - try - let newPath = g:NERDTreePath.Create(newNodeName) - let parentNode = b:NERDTreeRoot.findNode(newPath.getParent()) - - let newTreeNode = g:NERDTreeFileNode.New(newPath) - if parentNode.isOpen || !empty(parentNode.children) - call parentNode.addChild(newTreeNode, 1) - call NERDTreeRender() - call newTreeNode.putCursorHere(1, 0) - endif - catch /^NERDTree/ - call s:echoWarning("Node Not Created.") - endtry -endfunction - -"FUNCTION: NERDTreeMoveNode(){{{1 -function! NERDTreeMoveNode() - let curNode = g:NERDTreeFileNode.GetSelected() - let newNodePath = input("Rename the current node\n" . - \ "==========================================================\n" . - \ "Enter the new path for the node: \n" . - \ "", curNode.path.str(), "file") - - if newNodePath ==# '' - call s:echo("Node Renaming Aborted.") - return - endif - - try - let bufnum = bufnr(curNode.path.str()) - - call curNode.rename(newNodePath) - call NERDTreeRender() - - "if the node is open in a buffer, ask the user if they want to - "close that buffer - if bufnum != -1 - let prompt = "\nNode renamed.\n\nThe old file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Replace this buffer with a new file? (yN)" - call s:promptToRenameBuffer(bufnum, prompt, newNodePath) - endif - - call curNode.putCursorHere(1, 0) - - redraw - catch /^NERDTree/ - call s:echoWarning("Node Not Renamed.") - endtry -endfunction - -" FUNCTION: NERDTreeDeleteNode() {{{1 -function! NERDTreeDeleteNode() - let currentNode = g:NERDTreeFileNode.GetSelected() - let confirmed = 0 - - if currentNode.path.isDirectory - let choice =input("Delete the current node\n" . - \ "==========================================================\n" . - \ "STOP! To delete this entire directory, type 'yes'\n" . - \ "" . currentNode.path.str() . ": ") - let confirmed = choice ==# 'yes' - else - echo "Delete the current node\n" . - \ "==========================================================\n". - \ "Are you sure you wish to delete the node:\n" . - \ "" . currentNode.path.str() . " (yN):" - let choice = nr2char(getchar()) - let confirmed = choice ==# 'y' - endif - - - if confirmed - try - call currentNode.delete() - call NERDTreeRender() - - "if the node is open in a buffer, ask the user if they want to - "close that buffer - let bufnum = bufnr(currentNode.path.str()) - if buflisted(bufnum) - let prompt = "\nNode deleted.\n\nThe file is open in buffer ". bufnum . (bufwinnr(bufnum) ==# -1 ? " (hidden)" : "") .". Delete this buffer? (yN)" - call s:promptToDelBuffer(bufnum, prompt) - endif - - redraw - catch /^NERDTree/ - call s:echoWarning("Could not remove node") - endtry - else - call s:echo("delete aborted") - endif - -endfunction - -" FUNCTION: NERDTreeCopyNode() {{{1 -function! NERDTreeCopyNode() - let currentNode = g:NERDTreeFileNode.GetSelected() - let newNodePath = input("Copy the current node\n" . - \ "==========================================================\n" . - \ "Enter the new path to copy the node to: \n" . - \ "", currentNode.path.str(), "file") - - if newNodePath != "" - "strip trailing slash - let newNodePath = substitute(newNodePath, '\/$', '', '') - - let confirmed = 1 - if currentNode.path.copyingWillOverwrite(newNodePath) - call s:echo("Warning: copying may overwrite files! Continue? (yN)") - let choice = nr2char(getchar()) - let confirmed = choice ==# 'y' - endif - - if confirmed - try - let newNode = currentNode.copy(newNodePath) - if !empty(newNode) - call NERDTreeRender() - call newNode.putCursorHere(0, 0) - endif - catch /^NERDTree/ - call s:echoWarning("Could not copy node") - endtry - endif - else - call s:echo("Copy aborted.") - endif - redraw -endfunction - -function! NERDTreeQuickLook() - let treenode = g:NERDTreeFileNode.GetSelected() - if treenode != {} - call system("qlmanage -p 2>/dev/null '" . treenode.path.str() . "'") - endif -endfunction - -function! NERDTreeRevealInFinder() - let treenode = g:NERDTreeFileNode.GetSelected() - if treenode != {} - let x = system("open -R '" . treenode.path.str() . "'") - endif -endfunction - -function! NERDTreeExecuteFile() - let treenode = g:NERDTreeFileNode.GetSelected() - if treenode != {} - let x = system("open '" . treenode.path.str() . "'") - endif -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/NERD_tree.vim b/common/.vim/bundle/nerdtree/plugin/NERD_tree.vim deleted file mode 100644 index 8b853d4..0000000 --- a/common/.vim/bundle/nerdtree/plugin/NERD_tree.vim +++ /dev/null @@ -1,218 +0,0 @@ -" ============================================================================ -" File: NERD_tree.vim -" Description: vim global plugin that provides a nice tree explorer -" Maintainer: Martin Grenfell -" Last Change: 28 December, 2011 -" License: This program is free software. It comes without any warranty, -" to the extent permitted by applicable law. You can redistribute -" it and/or modify it under the terms of the Do What The Fuck You -" Want To Public License, Version 2, as published by Sam Hocevar. -" See http://sam.zoy.org/wtfpl/COPYING for more details. -" -" ============================================================================ -" -" SECTION: Script init stuff {{{1 -"============================================================ -if exists("loaded_nerd_tree") - finish -endif -if v:version < 700 - echoerr "NERDTree: this plugin requires vim >= 7. DOWNLOAD IT! You'll thank me later!" - finish -endif -let loaded_nerd_tree = 1 - -"for line continuation - i.e dont want C in &cpo -let s:old_cpo = &cpo -set cpo&vim - -"Function: s:initVariable() function {{{2 -"This function is used to initialise a given variable to a given value. The -"variable is only initialised if it does not exist prior -" -"Args: -"var: the name of the var to be initialised -"value: the value to initialise var to -" -"Returns: -"1 if the var is set, 0 otherwise -function! s:initVariable(var, value) - if !exists(a:var) - exec 'let ' . a:var . ' = ' . "'" . substitute(a:value, "'", "''", "g") . "'" - return 1 - endif - return 0 -endfunction - -"SECTION: Init variable calls and other random constants {{{2 -call s:initVariable("g:NERDChristmasTree", 1) -call s:initVariable("g:NERDTreeAutoCenter", 1) -call s:initVariable("g:NERDTreeAutoCenterThreshold", 3) -call s:initVariable("g:NERDTreeCaseSensitiveSort", 0) -call s:initVariable("g:NERDTreeChDirMode", 0) -call s:initVariable("g:NERDTreeMinimalUI", 0) -if !exists("g:NERDTreeIgnore") - let g:NERDTreeIgnore = ['\~$'] -endif -call s:initVariable("g:NERDTreeBookmarksFile", expand('$HOME') . '/.NERDTreeBookmarks') -call s:initVariable("g:NERDTreeHighlightCursorline", 1) -call s:initVariable("g:NERDTreeHijackNetrw", 1) -call s:initVariable("g:NERDTreeMouseMode", 1) -call s:initVariable("g:NERDTreeNotificationThreshold", 100) -call s:initVariable("g:NERDTreeQuitOnOpen", 0) -call s:initVariable("g:NERDTreeShowBookmarks", 0) -call s:initVariable("g:NERDTreeShowFiles", 1) -call s:initVariable("g:NERDTreeShowHidden", 0) -call s:initVariable("g:NERDTreeShowLineNumbers", 0) -call s:initVariable("g:NERDTreeSortDirs", 1) -call s:initVariable("g:NERDTreeDirArrows", !nerdtree#runningWindows()) -call s:initVariable("g:NERDTreeCasadeOpenSingleChildDir", 1) - -if !exists("g:NERDTreeSortOrder") - let g:NERDTreeSortOrder = ['\/$', '*', '\.swp$', '\.bak$', '\~$'] -else - "if there isnt a * in the sort sequence then add one - if count(g:NERDTreeSortOrder, '*') < 1 - call add(g:NERDTreeSortOrder, '*') - endif -endif - -if !exists('g:NERDTreeStatusline') - - "the exists() crap here is a hack to stop vim spazzing out when - "loading a session that was created with an open nerd tree. It spazzes - "because it doesnt store b:NERDTreeRoot (its a b: var, and its a hash) - let g:NERDTreeStatusline = "%{exists('b:NERDTreeRoot')?b:NERDTreeRoot.path.str():''}" - -endif -call s:initVariable("g:NERDTreeWinPos", "left") -call s:initVariable("g:NERDTreeWinSize", 31) - -"init the shell commands that will be used to copy nodes, and remove dir trees -" -"Note: the space after the command is important -if nerdtree#runningWindows() - call s:initVariable("g:NERDTreeRemoveDirCmd", 'rmdir /s /q ') -else - call s:initVariable("g:NERDTreeRemoveDirCmd", 'rm -rf ') - call s:initVariable("g:NERDTreeCopyCmd", 'cp -r ') -endif - - -"SECTION: Init variable calls for key mappings {{{2 -call s:initVariable("g:NERDTreeMapActivateNode", "o") -call s:initVariable("g:NERDTreeMapChangeRoot", "C") -call s:initVariable("g:NERDTreeMapChdir", "cd") -call s:initVariable("g:NERDTreeMapCloseChildren", "X") -call s:initVariable("g:NERDTreeMapCloseDir", "x") -call s:initVariable("g:NERDTreeMapDeleteBookmark", "D") -call s:initVariable("g:NERDTreeMapMenu", "m") -call s:initVariable("g:NERDTreeMapHelp", "?") -call s:initVariable("g:NERDTreeMapJumpFirstChild", "K") -call s:initVariable("g:NERDTreeMapJumpLastChild", "J") -call s:initVariable("g:NERDTreeMapJumpNextSibling", "") -call s:initVariable("g:NERDTreeMapJumpParent", "p") -call s:initVariable("g:NERDTreeMapJumpPrevSibling", "") -call s:initVariable("g:NERDTreeMapJumpRoot", "P") -call s:initVariable("g:NERDTreeMapOpenExpl", "e") -call s:initVariable("g:NERDTreeMapOpenInTab", "t") -call s:initVariable("g:NERDTreeMapOpenInTabSilent", "T") -call s:initVariable("g:NERDTreeMapOpenRecursively", "O") -call s:initVariable("g:NERDTreeMapOpenSplit", "i") -call s:initVariable("g:NERDTreeMapOpenVSplit", "s") -call s:initVariable("g:NERDTreeMapPreview", "g" . NERDTreeMapActivateNode) -call s:initVariable("g:NERDTreeMapPreviewSplit", "g" . NERDTreeMapOpenSplit) -call s:initVariable("g:NERDTreeMapPreviewVSplit", "g" . NERDTreeMapOpenVSplit) -call s:initVariable("g:NERDTreeMapQuit", "q") -call s:initVariable("g:NERDTreeMapRefresh", "r") -call s:initVariable("g:NERDTreeMapRefreshRoot", "R") -call s:initVariable("g:NERDTreeMapToggleBookmarks", "B") -call s:initVariable("g:NERDTreeMapToggleFiles", "F") -call s:initVariable("g:NERDTreeMapToggleFilters", "f") -call s:initVariable("g:NERDTreeMapToggleHidden", "I") -call s:initVariable("g:NERDTreeMapToggleZoom", "A") -call s:initVariable("g:NERDTreeMapUpdir", "u") -call s:initVariable("g:NERDTreeMapUpdirKeepOpen", "U") -call s:initVariable("g:NERDTreeMapCWD", "CD") - -"SECTION: Load class files{{{2 -runtime plugin/nerdtree/path.vim -runtime plugin/nerdtree/menu_controller.vim -runtime plugin/nerdtree/menu_item.vim -runtime plugin/nerdtree/key_map.vim -runtime plugin/nerdtree/bookmark.vim -runtime plugin/nerdtree/tree_file_node.vim -runtime plugin/nerdtree/tree_dir_node.vim -runtime plugin/nerdtree/opener.vim -runtime plugin/nerdtree/creator.vim - -" SECTION: Commands {{{1 -"============================================================ -"init the command that users start the nerd tree with -command! -n=? -complete=dir -bar NERDTree :call g:NERDTreeCreator.CreatePrimary('') -command! -n=? -complete=dir -bar NERDTreeToggle :call g:NERDTreeCreator.TogglePrimary('') -command! -n=0 -bar NERDTreeClose :call nerdtree#closeTreeIfOpen() -command! -n=1 -complete=customlist,nerdtree#completeBookmarks -bar NERDTreeFromBookmark call g:NERDTreeCreator.CreatePrimary('') -command! -n=0 -bar NERDTreeMirror call g:NERDTreeCreator.CreateMirror() -command! -n=0 -bar NERDTreeFind call nerdtree#findAndRevealPath() -command! -n=0 -bar NERDTreeFocus call NERDTreeFocus() -command! -n=0 -bar NERDTreeCWD call NERDTreeCWD() -" SECTION: Auto commands {{{1 -"============================================================ -augroup NERDTree - "Save the cursor position whenever we close the nerd tree - exec "autocmd BufWinLeave ". nerdtree#bufNamePrefix() ."* call nerdtree#saveScreenState()" - - "disallow insert mode in the NERDTree - exec "autocmd BufEnter ". nerdtree#bufNamePrefix() ."* stopinsert" -augroup END - -if g:NERDTreeHijackNetrw - augroup NERDTreeHijackNetrw - autocmd VimEnter * silent! autocmd! FileExplorer - au BufEnter,VimEnter * call nerdtree#checkForBrowse(expand("")) - augroup END -endif - -" SECTION: Public API {{{1 -"============================================================ -function! NERDTreeAddMenuItem(options) - call g:NERDTreeMenuItem.Create(a:options) -endfunction - -function! NERDTreeAddMenuSeparator(...) - let opts = a:0 ? a:1 : {} - call g:NERDTreeMenuItem.CreateSeparator(opts) -endfunction - -function! NERDTreeAddSubmenu(options) - return g:NERDTreeMenuItem.Create(a:options) -endfunction - -function! NERDTreeAddKeyMap(options) - call g:NERDTreeKeyMap.Create(a:options) -endfunction - -function! NERDTreeRender() - call nerdtree#renderView() -endfunction - -function! NERDTreeFocus() - if nerdtree#isTreeOpen() - call nerdtree#putCursorInTreeWin() - else - call g:NERDTreeCreator.TogglePrimary("") - endif -endfunction - -function! NERDTreeCWD() - call NERDTreeFocus() - call nerdtree#chRootCwd() -endfunction -" SECTION: Post Source Actions {{{1 -call nerdtree#postSourceActions() - -"reset &cpo back to users setting -let &cpo = s:old_cpo - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/bookmark.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/bookmark.vim deleted file mode 100644 index 0d37b47..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/bookmark.vim +++ /dev/null @@ -1,315 +0,0 @@ -"CLASS: Bookmark -"============================================================ -let s:Bookmark = {} -let g:NERDTreeBookmark = s:Bookmark - -" FUNCTION: Bookmark.activate() {{{1 -function! s:Bookmark.activate(...) - call self.open(a:0 ? a:1 : {}) -endfunction - -" FUNCTION: Bookmark.AddBookmark(name, path) {{{1 -" Class method to add a new bookmark to the list, if a previous bookmark exists -" with the same name, just update the path for that bookmark -function! s:Bookmark.AddBookmark(name, path) - for i in s:Bookmark.Bookmarks() - if i.name ==# a:name - let i.path = a:path - return - endif - endfor - call add(s:Bookmark.Bookmarks(), s:Bookmark.New(a:name, a:path)) - call s:Bookmark.Sort() -endfunction - -" FUNCTION: Bookmark.Bookmarks() {{{1 -" Class method to get all bookmarks. Lazily initializes the bookmarks global -" variable -function! s:Bookmark.Bookmarks() - if !exists("g:NERDTreeBookmarks") - let g:NERDTreeBookmarks = [] - endif - return g:NERDTreeBookmarks -endfunction - -" FUNCTION: Bookmark.BookmarkExistsFor(name) {{{1 -" class method that returns 1 if a bookmark with the given name is found, 0 -" otherwise -function! s:Bookmark.BookmarkExistsFor(name) - try - call s:Bookmark.BookmarkFor(a:name) - return 1 - catch /^NERDTree.BookmarkNotFoundError/ - return 0 - endtry -endfunction - -" FUNCTION: Bookmark.BookmarkFor(name) {{{1 -" Class method to get the bookmark that has the given name. {} is return if no -" bookmark is found -function! s:Bookmark.BookmarkFor(name) - for i in s:Bookmark.Bookmarks() - if i.name ==# a:name - return i - endif - endfor - throw "NERDTree.BookmarkNotFoundError: no bookmark found for name: \"". a:name .'"' -endfunction - -" FUNCTION: Bookmark.BookmarkNames() {{{1 -" Class method to return an array of all bookmark names -function! s:Bookmark.BookmarkNames() - let names = [] - for i in s:Bookmark.Bookmarks() - call add(names, i.name) - endfor - return names -endfunction - -" FUNCTION: Bookmark.CacheBookmarks(silent) {{{1 -" Class method to read all bookmarks from the bookmarks file intialize -" bookmark objects for each one. -" -" Args: -" silent - dont echo an error msg if invalid bookmarks are found -function! s:Bookmark.CacheBookmarks(silent) - if filereadable(g:NERDTreeBookmarksFile) - let g:NERDTreeBookmarks = [] - let g:NERDTreeInvalidBookmarks = [] - let bookmarkStrings = readfile(g:NERDTreeBookmarksFile) - let invalidBookmarksFound = 0 - for i in bookmarkStrings - - "ignore blank lines - if i != '' - - let name = substitute(i, '^\(.\{-}\) .*$', '\1', '') - let path = substitute(i, '^.\{-} \(.*\)$', '\1', '') - - try - let bookmark = s:Bookmark.New(name, g:NERDTreePath.New(path)) - call add(g:NERDTreeBookmarks, bookmark) - catch /^NERDTree.InvalidArgumentsError/ - call add(g:NERDTreeInvalidBookmarks, i) - let invalidBookmarksFound += 1 - endtry - endif - endfor - if invalidBookmarksFound - call s:Bookmark.Write() - if !a:silent - call nerdtree#echo(invalidBookmarksFound . " invalid bookmarks were read. See :help NERDTreeInvalidBookmarks for info.") - endif - endif - call s:Bookmark.Sort() - endif -endfunction - -" FUNCTION: Bookmark.compareTo(otherbookmark) {{{1 -" Compare these two bookmarks for sorting purposes -function! s:Bookmark.compareTo(otherbookmark) - return a:otherbookmark.name < self.name -endfunction -" FUNCTION: Bookmark.ClearAll() {{{1 -" Class method to delete all bookmarks. -function! s:Bookmark.ClearAll() - for i in s:Bookmark.Bookmarks() - call i.delete() - endfor - call s:Bookmark.Write() -endfunction - -" FUNCTION: Bookmark.delete() {{{1 -" Delete this bookmark. If the node for this bookmark is under the current -" root, then recache bookmarks for its Path object -function! s:Bookmark.delete() - let node = {} - try - let node = self.getNode(1) - catch /^NERDTree.BookmarkedNodeNotFoundError/ - endtry - call remove(s:Bookmark.Bookmarks(), index(s:Bookmark.Bookmarks(), self)) - if !empty(node) - call node.path.cacheDisplayString() - endif - call s:Bookmark.Write() -endfunction - -" FUNCTION: Bookmark.getNode(searchFromAbsoluteRoot) {{{1 -" Gets the treenode for this bookmark -" -" Args: -" searchFromAbsoluteRoot: specifies whether we should search from the current -" tree root, or the highest cached node -function! s:Bookmark.getNode(searchFromAbsoluteRoot) - let searchRoot = a:searchFromAbsoluteRoot ? g:NERDTreeDirNode.AbsoluteTreeRoot() : b:NERDTreeRoot - let targetNode = searchRoot.findNode(self.path) - if empty(targetNode) - throw "NERDTree.BookmarkedNodeNotFoundError: no node was found for bookmark: " . self.name - endif - return targetNode -endfunction - -" FUNCTION: Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) {{{1 -" Class method that finds the bookmark with the given name and returns the -" treenode for it. -function! s:Bookmark.GetNodeForName(name, searchFromAbsoluteRoot) - let bookmark = s:Bookmark.BookmarkFor(a:name) - return bookmark.getNode(a:searchFromAbsoluteRoot) -endfunction - -" FUNCTION: Bookmark.GetSelected() {{{1 -" returns the Bookmark the cursor is over, or {} -function! s:Bookmark.GetSelected() - let line = getline(".") - let name = substitute(line, '^>\(.\{-}\) .\+$', '\1', '') - if name != line - try - return s:Bookmark.BookmarkFor(name) - catch /^NERDTree.BookmarkNotFoundError/ - return {} - endtry - endif - return {} -endfunction - -" FUNCTION: Bookmark.InvalidBookmarks() {{{1 -" Class method to get all invalid bookmark strings read from the bookmarks -" file -function! s:Bookmark.InvalidBookmarks() - if !exists("g:NERDTreeInvalidBookmarks") - let g:NERDTreeInvalidBookmarks = [] - endif - return g:NERDTreeInvalidBookmarks -endfunction - -" FUNCTION: Bookmark.mustExist() {{{1 -function! s:Bookmark.mustExist() - if !self.path.exists() - call s:Bookmark.CacheBookmarks(1) - throw "NERDTree.BookmarkPointsToInvalidLocationError: the bookmark \"". - \ self.name ."\" points to a non existing location: \"". self.path.str() - endif -endfunction - -" FUNCTION: Bookmark.New(name, path) {{{1 -" Create a new bookmark object with the given name and path object -function! s:Bookmark.New(name, path) - if a:name =~# ' ' - throw "NERDTree.IllegalBookmarkNameError: illegal name:" . a:name - endif - - let newBookmark = copy(self) - let newBookmark.name = a:name - let newBookmark.path = a:path - return newBookmark -endfunction - -" FUNCTION: Bookmark.open([options]) {{{1 -"Args: -"A dictionary containing the following keys (all optional): -" 'where': Specifies whether the node should be opened in new split/tab or in -" the previous window. Can be either 'v' (vertical split), 'h' -" (horizontal split), 't' (new tab) or 'p' (previous window). -" 'reuse': if a window is displaying the file then jump the cursor there -" 'keepopen': dont close the tree window -" 'stay': open the file, but keep the cursor in the tree win -" -function! s:Bookmark.open(...) - let opts = a:0 ? a:1 : {} - - if self.path.isDirectory && !has_key(opts, 'where') - call self.toRoot() - else - let opener = g:NERDTreeOpener.New(self.path, opts) - call opener.open(self) - endif -endfunction - -" FUNCTION: Bookmark.openInNewTab(options) {{{1 -" Create a new bookmark object with the given name and path object -function! s:Bookmark.openInNewTab(options) - call nerdtree#deprecated('Bookmark.openInNewTab', 'is deprecated, use open() instead') - call self.open(a:options) -endfunction - -" FUNCTION: Bookmark.setPath(path) {{{1 -" makes this bookmark point to the given path -function! s:Bookmark.setPath(path) - let self.path = a:path -endfunction - -" FUNCTION: Bookmark.Sort() {{{1 -" Class method that sorts all bookmarks -function! s:Bookmark.Sort() - let CompareFunc = function("nerdtree#compareBookmarks") - call sort(s:Bookmark.Bookmarks(), CompareFunc) -endfunction - -" FUNCTION: Bookmark.str() {{{1 -" Get the string that should be rendered in the view for this bookmark -function! s:Bookmark.str() - let pathStrMaxLen = winwidth(nerdtree#getTreeWinNum()) - 4 - len(self.name) - if &nu - let pathStrMaxLen = pathStrMaxLen - &numberwidth - endif - - let pathStr = self.path.str({'format': 'UI'}) - if len(pathStr) > pathStrMaxLen - let pathStr = '<' . strpart(pathStr, len(pathStr) - pathStrMaxLen) - endif - return '>' . self.name . ' ' . pathStr -endfunction - -" FUNCTION: Bookmark.toRoot() {{{1 -" Make the node for this bookmark the new tree root -function! s:Bookmark.toRoot() - if self.validate() - try - let targetNode = self.getNode(1) - catch /^NERDTree.BookmarkedNodeNotFoundError/ - let targetNode = g:NERDTreeFileNode.New(s:Bookmark.BookmarkFor(self.name).path) - endtry - call targetNode.makeRoot() - call nerdtree#renderView() - call targetNode.putCursorHere(0, 0) - endif -endfunction - -" FUNCTION: Bookmark.ToRoot(name) {{{1 -" Make the node for this bookmark the new tree root -function! s:Bookmark.ToRoot(name) - let bookmark = s:Bookmark.BookmarkFor(a:name) - call bookmark.toRoot() -endfunction - -" FUNCTION: Bookmark.validate() {{{1 -function! s:Bookmark.validate() - if self.path.exists() - return 1 - else - call s:Bookmark.CacheBookmarks(1) - call nerdtree#renderView() - call nerdtree#echo(self.name . "now points to an invalid location. See :help NERDTreeInvalidBookmarks for info.") - return 0 - endif -endfunction - -" FUNCTION: Bookmark.Write() {{{1 -" Class method to write all bookmarks to the bookmarks file -function! s:Bookmark.Write() - let bookmarkStrings = [] - for i in s:Bookmark.Bookmarks() - call add(bookmarkStrings, i.name . ' ' . i.path.str()) - endfor - - "add a blank line before the invalid ones - call add(bookmarkStrings, "") - - for j in s:Bookmark.InvalidBookmarks() - call add(bookmarkStrings, j) - endfor - call writefile(bookmarkStrings, g:NERDTreeBookmarksFile) -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/creator.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/creator.vim deleted file mode 100644 index 5adc960..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/creator.vim +++ /dev/null @@ -1,298 +0,0 @@ -"CLASS: Creator -"Creates primary/secondary/mirror nerdtree windows. Sets up all the window and -"buffer options and key mappings etc. -"============================================================ -let s:Creator = {} -let g:NERDTreeCreator = s:Creator - -"FUNCTION: s:Creator._bindMappings() {{{1 -function! s:Creator._bindMappings() - call g:NERDTreeKeyMap.BindAll() - - "make do the same as the default 'o' mapping - exec "nnoremap :call nerdtree#invokeKeyMap('". g:NERDTreeMapActivateNode ."')" - - command! -buffer -nargs=? Bookmark :call nerdtree#bookmarkNode('') - command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 RevealBookmark :call nerdtree#revealBookmark('') - command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=1 OpenBookmark :call nerdtree#openBookmark('') - command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=* ClearBookmarks call nerdtree#clearBookmarks('') - command! -buffer -complete=customlist,nerdtree#completeBookmarks -nargs=+ BookmarkToRoot call g:NERDTreeBookmark.ToRoot('') - command! -buffer -nargs=0 ClearAllBookmarks call g:NERDTreeBookmark.ClearAll() call nerdtree#renderView() - command! -buffer -nargs=0 ReadBookmarks call g:NERDTreeBookmark.CacheBookmarks(0) call nerdtree#renderView() - command! -buffer -nargs=0 WriteBookmarks call g:NERDTreeBookmark.Write() -endfunction - -"FUNCTION: s:Creator._broadcastInitEvent() {{{1 -function! s:Creator._broadcastInitEvent() - silent doautocmd User NERDTreeInit -endfunction - -"FUNCTION: s:Creator.CreatePrimary(a:name) {{{1 -function! s:Creator.CreatePrimary(name) - let creator = s:Creator.New() - call creator.createPrimary(a:name) -endfunction - -"FUNCTION: s:Creator.createPrimary(a:name) {{{1 -"name: the name of a bookmark or a directory -function! s:Creator.createPrimary(name) - let path = self._pathForString(a:name) - - "if instructed to, then change the vim CWD to the dir the NERDTree is - "inited in - if g:NERDTreeChDirMode != 0 - call path.changeToDir() - endif - - if nerdtree#treeExistsForTab() - if nerdtree#isTreeOpen() - call nerdtree#closeTree() - endif - unlet t:NERDTreeBufName - endif - - let newRoot = g:NERDTreeDirNode.New(path) - call newRoot.open() - - call self._createTreeWin() - let b:treeShowHelp = 0 - let b:NERDTreeIgnoreEnabled = 1 - let b:NERDTreeShowFiles = g:NERDTreeShowFiles - let b:NERDTreeShowHidden = g:NERDTreeShowHidden - let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks - let b:NERDTreeRoot = newRoot - let b:NERDTreeType = "primary" - - call nerdtree#renderView() - call b:NERDTreeRoot.putCursorHere(0, 0) - - call self._broadcastInitEvent() -endfunction - -"FUNCTION: s:Creator.CreateSecondary(dir) {{{1 -function! s:Creator.CreateSecondary(dir) - let creator = s:Creator.New() - call creator.createSecondary(a:dir) -endfunction - -"FUNCTION: s:Creator.createSecondary(dir) {{{1 -function! s:Creator.createSecondary(dir) - try - let path = g:NERDTreePath.New(a:dir) - catch /^NERDTree.InvalidArgumentsError/ - call nerdtree#echo("Invalid directory name:" . a:name) - return - endtry - - "we want the directory buffer to disappear when we do the :edit below - setlocal bufhidden=wipe - - let previousBuf = expand("#") - - "we need a unique name for each secondary tree buffer to ensure they are - "all independent - exec "silent edit " . nerdtree#nextBufferName() - - let b:NERDTreePreviousBuf = bufnr(previousBuf) - - let b:NERDTreeRoot = g:NERDTreeDirNode.New(path) - call b:NERDTreeRoot.open() - - call self._setCommonBufOptions() - let b:NERDTreeType = "secondary" - - call nerdtree#renderView() - - call self._broadcastInitEvent() -endfunction - -" FUNCTION: s:Creator.CreateMirror() {{{1 -function! s:Creator.CreateMirror() - let creator = s:Creator.New() - call creator.createMirror() -endfunction - -" FUNCTION: s:Creator.createMirror() {{{1 -function! s:Creator.createMirror() - "get the names off all the nerd tree buffers - let treeBufNames = [] - for i in range(1, tabpagenr("$")) - let nextName = nerdtree#tabpagevar(i, 'NERDTreeBufName') - if nextName != -1 && (!exists("t:NERDTreeBufName") || nextName != t:NERDTreeBufName) - call add(treeBufNames, nextName) - endif - endfor - let treeBufNames = nerdtree#unique(treeBufNames) - - "map the option names (that the user will be prompted with) to the nerd - "tree buffer names - let options = {} - let i = 0 - while i < len(treeBufNames) - let bufName = treeBufNames[i] - let treeRoot = getbufvar(bufName, "NERDTreeRoot") - let options[i+1 . '. ' . treeRoot.path.str() . ' (buf name: ' . bufName . ')'] = bufName - let i = i + 1 - endwhile - - "work out which tree to mirror, if there is more than 1 then ask the user - let bufferName = '' - if len(keys(options)) > 1 - let choices = ["Choose a tree to mirror"] - let choices = extend(choices, sort(keys(options))) - let choice = inputlist(choices) - if choice < 1 || choice > len(options) || choice ==# '' - return - endif - - let bufferName = options[sort(keys(options))[choice-1]] - elseif len(keys(options)) ==# 1 - let bufferName = values(options)[0] - else - call nerdtree#echo("No trees to mirror") - return - endif - - if nerdtree#treeExistsForTab() && nerdtree#isTreeOpen() - call nerdtree#closeTree() - endif - - let t:NERDTreeBufName = bufferName - call self._createTreeWin() - exec 'buffer ' . bufferName - if !&hidden - call nerdtree#renderView() - endif -endfunction - -"FUNCTION: s:Creator._createTreeWin() {{{1 -"Inits the NERD tree window. ie. opens it, sizes it, sets all the local -"options etc -function! s:Creator._createTreeWin() - "create the nerd tree window - let splitLocation = g:NERDTreeWinPos ==# "left" ? "topleft " : "botright " - let splitSize = g:NERDTreeWinSize - - if !exists('t:NERDTreeBufName') - let t:NERDTreeBufName = nerdtree#nextBufferName() - silent! exec splitLocation . 'vertical ' . splitSize . ' new' - silent! exec "edit " . t:NERDTreeBufName - else - silent! exec splitLocation . 'vertical ' . splitSize . ' split' - silent! exec "buffer " . t:NERDTreeBufName - endif - - setlocal winfixwidth - call self._setCommonBufOptions() -endfunction - -"FUNCTION: s:Creator.New() {{{1 -function! s:Creator.New() - let newCreator = copy(self) - return newCreator -endfunction - -"FUNCTION: s:Creator._pathForString(str) {{{1 -"find a bookmark or adirectory for the given string -function! s:Creator._pathForString(str) - let path = {} - if g:NERDTreeBookmark.BookmarkExistsFor(a:str) - let path = g:NERDTreeBookmark.BookmarkFor(a:str).path - else - let dir = a:str ==# '' ? getcwd() : a:str - - "hack to get an absolute path if a relative path is given - if dir =~# '^\.' - let dir = getcwd() . g:NERDTreePath.Slash() . dir - endif - let dir = g:NERDTreePath.Resolve(dir) - - try - let path = g:NERDTreePath.New(dir) - catch /^NERDTree.InvalidArgumentsError/ - call nerdtree#echo("No bookmark or directory found for: " . a:str) - return - endtry - endif - if !path.isDirectory - let path = path.getParent() - endif - - return path -endfunction - -"FUNCTION: s:Creator._setCommonBufOptions() {{{1 -function! s:Creator._setCommonBufOptions() - "throwaway buffer options - setlocal noswapfile - setlocal buftype=nofile - setlocal bufhidden=hide - setlocal nowrap - setlocal foldcolumn=0 - setlocal foldmethod=manual - setlocal nofoldenable - setlocal nobuflisted - setlocal nospell - if g:NERDTreeShowLineNumbers - setlocal nu - else - setlocal nonu - if v:version >= 703 - setlocal nornu - endif - endif - - iabc - - if g:NERDTreeHighlightCursorline - setlocal cursorline - endif - - call self._setupStatusline() - - let b:treeShowHelp = 0 - let b:NERDTreeIgnoreEnabled = 1 - let b:NERDTreeShowFiles = g:NERDTreeShowFiles - let b:NERDTreeShowHidden = g:NERDTreeShowHidden - let b:NERDTreeShowBookmarks = g:NERDTreeShowBookmarks - setfiletype nerdtree - call self._bindMappings() -endfunction - -"FUNCTION: s:Creator._setupStatusline() {{{1 -function! s:Creator._setupStatusline() - if g:NERDTreeStatusline != -1 - let &l:statusline = g:NERDTreeStatusline - endif -endfunction - -"FUNCTION: s:Creator.TogglePrimary(dir) {{{1 -function! s:Creator.TogglePrimary(dir) - let creator = s:Creator.New() - call creator.togglePrimary(a:dir) -endfunction - -"FUNCTION: s:Creator.togglePrimary(dir) {{{1 -"Toggles the NERD tree. I.e the NERD tree is open, it is closed, if it is -"closed it is restored or initialized (if it doesnt exist) -" -"Args: -"dir: the full path for the root node (is only used if the NERD tree is being -"initialized. -function! s:Creator.togglePrimary(dir) - if nerdtree#treeExistsForTab() - if !nerdtree#isTreeOpen() - call self._createTreeWin() - if !&hidden - call nerdtree#renderView() - endif - call nerdtree#restoreScreenState() - else - call nerdtree#closeTree() - endif - else - call self.createPrimary(a:dir) - endif -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/key_map.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/key_map.vim deleted file mode 100644 index 8645765..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/key_map.vim +++ /dev/null @@ -1,143 +0,0 @@ -"CLASS: KeyMap -"============================================================ -let s:KeyMap = {} -let g:NERDTreeKeyMap = s:KeyMap - -"FUNCTION: KeyMap.All() {{{1 -function! s:KeyMap.All() - if !exists("s:keyMaps") - let s:keyMaps = [] - endif - return s:keyMaps -endfunction - -"FUNCTION: KeyMap.FindFor(key, scope) {{{1 -function! s:KeyMap.FindFor(key, scope) - for i in s:KeyMap.All() - if i.key ==# a:key && i.scope ==# a:scope - return i - endif - endfor - return {} -endfunction - -"FUNCTION: KeyMap.BindAll() {{{1 -function! s:KeyMap.BindAll() - for i in s:KeyMap.All() - call i.bind() - endfor -endfunction - -"FUNCTION: KeyMap.bind() {{{1 -function! s:KeyMap.bind() - " If the key sequence we're trying to map contains any '<>' notation, we - " must replace each of the '<' characters with '' to ensure the string - " is not translated into its corresponding keycode during the later part - " of the map command below - " :he <> - let specialNotationRegex = '\m<\([[:alnum:]_-]\+>\)' - if self.key =~# specialNotationRegex - let keymapInvokeString = substitute(self.key, specialNotationRegex, '\1', 'g') - else - let keymapInvokeString = self.key - endif - - let premap = self.key == "" ? " " : " " - - exec 'nnoremap '. self.key . premap . ':call nerdtree#invokeKeyMap("'. keymapInvokeString .'")' -endfunction - -"FUNCTION: KeyMap.Remove(key, scope) {{{1 -function! s:KeyMap.Remove(key, scope) - let maps = s:KeyMap.All() - for i in range(len(maps)) - if maps[i].key ==# a:key && maps[i].scope ==# a:scope - return remove(maps, i) - endif - endfor -endfunction - -"FUNCTION: KeyMap.invoke() {{{1 -"Call the KeyMaps callback function -function! s:KeyMap.invoke(...) - let Callback = function(self.callback) - if a:0 - call Callback(a:1) - else - call Callback() - endif -endfunction - -"FUNCTION: KeyMap.Invoke() {{{1 -"Find a keymapping for a:key and the current scope invoke it. -" -"Scope is determined as follows: -" * if the cursor is on a dir node then "DirNode" -" * if the cursor is on a file node then "FileNode" -" * if the cursor is on a bookmark then "Bookmark" -" -"If a keymap has the scope of "all" then it will be called if no other keymap -"is found for a:key and the scope. -function! s:KeyMap.Invoke(key) - let node = g:NERDTreeFileNode.GetSelected() - if !empty(node) - - "try file node - if !node.path.isDirectory - let km = s:KeyMap.FindFor(a:key, "FileNode") - if !empty(km) - return km.invoke(node) - endif - endif - - "try dir node - if node.path.isDirectory - let km = s:KeyMap.FindFor(a:key, "DirNode") - if !empty(km) - return km.invoke(node) - endif - endif - - "try generic node - let km = s:KeyMap.FindFor(a:key, "Node") - if !empty(km) - return km.invoke(node) - endif - - endif - - "try bookmark - let bm = g:NERDTreeBookmark.GetSelected() - if !empty(bm) - let km = s:KeyMap.FindFor(a:key, "Bookmark") - if !empty(km) - return km.invoke(bm) - endif - endif - - "try all - let km = s:KeyMap.FindFor(a:key, "all") - if !empty(km) - return km.invoke() - endif -endfunction - -"FUNCTION: KeyMap.Create(options) {{{1 -function! s:KeyMap.Create(options) - let newKeyMap = copy(self) - let opts = extend({'scope': 'all', 'quickhelpText': ''}, copy(a:options)) - let newKeyMap.key = opts['key'] - let newKeyMap.quickhelpText = opts['quickhelpText'] - let newKeyMap.callback = opts['callback'] - let newKeyMap.scope = opts['scope'] - - call s:KeyMap.Add(newKeyMap) -endfunction - -"FUNCTION: KeyMap.Add(keymap) {{{1 -function! s:KeyMap.Add(keymap) - call s:KeyMap.Remove(a:keymap.key, a:keymap.scope) - call add(s:KeyMap.All(), a:keymap) -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/menu_controller.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/menu_controller.vim deleted file mode 100644 index ae0ee84..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/menu_controller.vim +++ /dev/null @@ -1,180 +0,0 @@ -"CLASS: MenuController -"============================================================ -let s:MenuController = {} -let g:NERDTreeMenuController = s:MenuController - -"FUNCTION: MenuController.New(menuItems) {{{1 -"create a new menu controller that operates on the given menu items -function! s:MenuController.New(menuItems) - let newMenuController = copy(self) - if a:menuItems[0].isSeparator() - let newMenuController.menuItems = a:menuItems[1:-1] - else - let newMenuController.menuItems = a:menuItems - endif - return newMenuController -endfunction - -"FUNCTION: MenuController.showMenu() {{{1 -"start the main loop of the menu and get the user to choose/execute a menu -"item -function! s:MenuController.showMenu() - call self._saveOptions() - - try - let self.selection = 0 - - let done = 0 - while !done - redraw! - call self._echoPrompt() - let key = nr2char(getchar()) - let done = self._handleKeypress(key) - endwhile - finally - call self._restoreOptions() - endtry - - if self.selection != -1 - let m = self._current() - call m.execute() - endif -endfunction - -"FUNCTION: MenuController._echoPrompt() {{{1 -function! s:MenuController._echoPrompt() - echo "NERDTree Menu. Use j/k/enter and the shortcuts indicated" - echo "==========================================================" - - for i in range(0, len(self.menuItems)-1) - if self.selection == i - echo "> " . self.menuItems[i].text - else - echo " " . self.menuItems[i].text - endif - endfor -endfunction - -"FUNCTION: MenuController._current(key) {{{1 -"get the MenuItem that is currently selected -function! s:MenuController._current() - return self.menuItems[self.selection] -endfunction - -"FUNCTION: MenuController._handleKeypress(key) {{{1 -"change the selection (if appropriate) and return 1 if the user has made -"their choice, 0 otherwise -function! s:MenuController._handleKeypress(key) - if a:key == 'j' - call self._cursorDown() - elseif a:key == 'k' - call self._cursorUp() - elseif a:key == nr2char(27) "escape - let self.selection = -1 - return 1 - elseif a:key == "\r" || a:key == "\n" "enter and ctrl-j - return 1 - else - let index = self._nextIndexFor(a:key) - if index != -1 - let self.selection = index - if len(self._allIndexesFor(a:key)) == 1 - return 1 - endif - endif - endif - - return 0 -endfunction - -"FUNCTION: MenuController._allIndexesFor(shortcut) {{{1 -"get indexes to all menu items with the given shortcut -function! s:MenuController._allIndexesFor(shortcut) - let toReturn = [] - - for i in range(0, len(self.menuItems)-1) - if self.menuItems[i].shortcut == a:shortcut - call add(toReturn, i) - endif - endfor - - return toReturn -endfunction - -"FUNCTION: MenuController._nextIndexFor(shortcut) {{{1 -"get the index to the next menu item with the given shortcut, starts from the -"current cursor location and wraps around to the top again if need be -function! s:MenuController._nextIndexFor(shortcut) - for i in range(self.selection+1, len(self.menuItems)-1) - if self.menuItems[i].shortcut == a:shortcut - return i - endif - endfor - - for i in range(0, self.selection) - if self.menuItems[i].shortcut == a:shortcut - return i - endif - endfor - - return -1 -endfunction - -"FUNCTION: MenuController._setCmdheight() {{{1 -"sets &cmdheight to whatever is needed to display the menu -function! s:MenuController._setCmdheight() - let &cmdheight = len(self.menuItems) + 3 -endfunction - -"FUNCTION: MenuController._saveOptions() {{{1 -"set any vim options that are required to make the menu work (saving their old -"values) -function! s:MenuController._saveOptions() - let self._oldLazyredraw = &lazyredraw - let self._oldCmdheight = &cmdheight - set nolazyredraw - call self._setCmdheight() -endfunction - -"FUNCTION: MenuController._restoreOptions() {{{1 -"restore the options we saved in _saveOptions() -function! s:MenuController._restoreOptions() - let &cmdheight = self._oldCmdheight - let &lazyredraw = self._oldLazyredraw -endfunction - -"FUNCTION: MenuController._cursorDown() {{{1 -"move the cursor to the next menu item, skipping separators -function! s:MenuController._cursorDown() - let done = 0 - while !done - if self.selection < len(self.menuItems)-1 - let self.selection += 1 - else - let self.selection = 0 - endif - - if !self._current().isSeparator() - let done = 1 - endif - endwhile -endfunction - -"FUNCTION: MenuController._cursorUp() {{{1 -"move the cursor to the previous menu item, skipping separators -function! s:MenuController._cursorUp() - let done = 0 - while !done - if self.selection > 0 - let self.selection -= 1 - else - let self.selection = len(self.menuItems)-1 - endif - - if !self._current().isSeparator() - let done = 1 - endif - endwhile -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/menu_item.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/menu_item.vim deleted file mode 100644 index 6fb9d9e..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/menu_item.vim +++ /dev/null @@ -1,114 +0,0 @@ -"CLASS: MenuItem -"============================================================ -let s:MenuItem = {} -let g:NERDTreeMenuItem = s:MenuItem - -"FUNCTION: MenuItem.All() {{{1 -"get all top level menu items -function! s:MenuItem.All() - if !exists("s:menuItems") - let s:menuItems = [] - endif - return s:menuItems -endfunction - -"FUNCTION: MenuItem.AllEnabled() {{{1 -"get all top level menu items that are currently enabled -function! s:MenuItem.AllEnabled() - let toReturn = [] - for i in s:MenuItem.All() - if i.enabled() - call add(toReturn, i) - endif - endfor - return toReturn -endfunction - -"FUNCTION: MenuItem.Create(options) {{{1 -"make a new menu item and add it to the global list -function! s:MenuItem.Create(options) - let newMenuItem = copy(self) - - let newMenuItem.text = a:options['text'] - let newMenuItem.shortcut = a:options['shortcut'] - let newMenuItem.children = [] - - let newMenuItem.isActiveCallback = -1 - if has_key(a:options, 'isActiveCallback') - let newMenuItem.isActiveCallback = a:options['isActiveCallback'] - endif - - let newMenuItem.callback = -1 - if has_key(a:options, 'callback') - let newMenuItem.callback = a:options['callback'] - endif - - if has_key(a:options, 'parent') - call add(a:options['parent'].children, newMenuItem) - else - call add(s:MenuItem.All(), newMenuItem) - endif - - return newMenuItem -endfunction - -"FUNCTION: MenuItem.CreateSeparator(options) {{{1 -"make a new separator menu item and add it to the global list -function! s:MenuItem.CreateSeparator(options) - let standard_options = { 'text': '--------------------', - \ 'shortcut': -1, - \ 'callback': -1 } - let options = extend(a:options, standard_options, "force") - - return s:MenuItem.Create(options) -endfunction - -"FUNCTION: MenuItem.CreateSubmenu(options) {{{1 -"make a new submenu and add it to global list -function! s:MenuItem.CreateSubmenu(options) - let standard_options = { 'callback': -1 } - let options = extend(a:options, standard_options, "force") - - return s:MenuItem.Create(options) -endfunction - -"FUNCTION: MenuItem.enabled() {{{1 -"return 1 if this menu item should be displayed -" -"delegates off to the isActiveCallback, and defaults to 1 if no callback was -"specified -function! s:MenuItem.enabled() - if self.isActiveCallback != -1 - return {self.isActiveCallback}() - endif - return 1 -endfunction - -"FUNCTION: MenuItem.execute() {{{1 -"perform the action behind this menu item, if this menuitem has children then -"display a new menu for them, otherwise deletegate off to the menuitem's -"callback -function! s:MenuItem.execute() - if len(self.children) - let mc = s:MenuController.New(self.children) - call mc.showMenu() - else - if self.callback != -1 - call {self.callback}() - endif - endif -endfunction - -"FUNCTION: MenuItem.isSeparator() {{{1 -"return 1 if this menuitem is a separator -function! s:MenuItem.isSeparator() - return self.callback == -1 && self.children == [] -endfunction - -"FUNCTION: MenuItem.isSubmenu() {{{1 -"return 1 if this menuitem is a submenu -function! s:MenuItem.isSubmenu() - return self.callback == -1 && !empty(self.children) -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/opener.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/opener.vim deleted file mode 100644 index bcc0d4f..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/opener.vim +++ /dev/null @@ -1,264 +0,0 @@ -"CLASS: Opener -"============================================================ -let s:Opener = {} -let g:NERDTreeOpener = s:Opener - -"FUNCTION: Opener._checkToCloseTree(newtab) {{{1 -"Check the class options and global options (i.e. NERDTreeQuitOnOpen) to see -"if the tree should be closed now. -" -"Args: -"a:newtab - boolean. If set, only close the tree now if we are opening the -"target in a new tab. This is needed because we have to close tree before we -"leave the tab -function! s:Opener._checkToCloseTree(newtab) - if self._keepopen - return - endif - - if (a:newtab && self._where == 't') || !a:newtab - call nerdtree#closeTreeIfQuitOnOpen() - endif -endfunction - -"FUNCTION: Opener._gotoTargetWin() {{{1 -function! s:Opener._gotoTargetWin() - if b:NERDTreeType ==# "secondary" - if self._where == 'v' - vsplit - elseif self._where == 'h' - split - elseif self._where == 't' - tabnew - endif - else - call self._checkToCloseTree(1) - - if self._where == 'v' - call self._newVSplit() - elseif self._where == 'h' - call self._newSplit() - elseif self._where == 't' - tabnew - elseif self._where == 'p' - call self._previousWindow() - endif - - call self._checkToCloseTree(0) - endif -endfunction - -"FUNCTION: Opener.New(path, opts) {{{1 -"Args: -" -"a:path: The path object that is to be opened. -" -"a:opts: -" -"A dictionary containing the following keys (all optional): -" 'where': Specifies whether the node should be opened in new split/tab or in -" the previous window. Can be either 'v' or 'h' or 't' (for open in -" new tab) -" 'reuse': if a window is displaying the file then jump the cursor there -" 'keepopen': dont close the tree window -" 'stay': open the file, but keep the cursor in the tree win -function! s:Opener.New(path, opts) - let newObj = copy(self) - - let newObj._path = a:path - let newObj._stay = nerdtree#has_opt(a:opts, 'stay') - let newObj._reuse = nerdtree#has_opt(a:opts, 'reuse') - let newObj._keepopen = nerdtree#has_opt(a:opts, 'keepopen') - let newObj._where = has_key(a:opts, 'where') ? a:opts['where'] : '' - let newObj._treetype = b:NERDTreeType - call newObj._saveCursorPos() - - return newObj -endfunction - -"FUNCTION: Opener._newSplit() {{{1 -function! s:Opener._newSplit() - " Save the user's settings for splitbelow and splitright - let savesplitbelow=&splitbelow - let savesplitright=&splitright - - " 'there' will be set to a command to move from the split window - " back to the explorer window - " - " 'back' will be set to a command to move from the explorer window - " back to the newly split window - " - " 'right' and 'below' will be set to the settings needed for - " splitbelow and splitright IF the explorer is the only window. - " - let there= g:NERDTreeWinPos ==# "left" ? "wincmd h" : "wincmd l" - let back = g:NERDTreeWinPos ==# "left" ? "wincmd l" : "wincmd h" - let right= g:NERDTreeWinPos ==# "left" - let below=0 - - " Attempt to go to adjacent window - call nerdtree#exec(back) - - let onlyOneWin = (winnr("$") ==# 1) - - " If no adjacent window, set splitright and splitbelow appropriately - if onlyOneWin - let &splitright=right - let &splitbelow=below - else - " found adjacent window - invert split direction - let &splitright=!right - let &splitbelow=!below - endif - - let splitMode = onlyOneWin ? "vertical" : "" - - " Open the new window - try - exec(splitMode." sp ") - catch /^Vim\%((\a\+)\)\=:E37/ - call nerdtree#putCursorInTreeWin() - throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified." - catch /^Vim\%((\a\+)\)\=:/ - "do nothing - endtry - - "resize the tree window if no other window was open before - if onlyOneWin - let size = exists("b:NERDTreeOldWindowSize") ? b:NERDTreeOldWindowSize : g:NERDTreeWinSize - call nerdtree#exec(there) - exec("silent ". splitMode ." resize ". size) - call nerdtree#exec('wincmd p') - endif - - " Restore splitmode settings - let &splitbelow=savesplitbelow - let &splitright=savesplitright -endfunction - -"FUNCTION: Opener._newVSplit() {{{1 -function! s:Opener._newVSplit() - let winwidth = winwidth(".") - if winnr("$")==#1 - let winwidth = g:NERDTreeWinSize - endif - - call nerdtree#exec("wincmd p") - vnew - - "resize the nerd tree back to the original size - call nerdtree#putCursorInTreeWin() - exec("silent vertical resize ". winwidth) - call nerdtree#exec('wincmd p') -endfunction - -"FUNCTION: Opener.open(target) {{{1 -function! s:Opener.open(target) - if self._path.isDirectory - call self._openDirectory(a:target) - else - call self._openFile() - endif -endfunction - -"FUNCTION: Opener._openFile() {{{1 -function! s:Opener._openFile() - if self._reuse && self._reuseWindow() - return - endif - - call self._gotoTargetWin() - - if self._treetype ==# "secondary" - call self._path.edit() - else - call self._path.edit() - - - if self._stay - call self._restoreCursorPos() - endif - endif -endfunction - -"FUNCTION: Opener._openDirectory(node) {{{1 -function! s:Opener._openDirectory(node) - if self._treetype ==# "secondary" - call self._gotoTargetWin() - call g:NERDTreeCreator.CreateSecondary(a:node.path.str()) - else - call self._gotoTargetWin() - if empty(self._where) - call a:node.makeRoot() - call nerdtree#renderView() - call a:node.putCursorHere(0, 0) - elseif self._where == 't' - call g:NERDTreeCreator.CreatePrimary(a:node.path.str()) - else - call g:NERDTreeCreator.CreateSecondary(a:node.path.str()) - endif - endif - - if self._stay - call self._restoreCursorPos() - endif -endfunction - -"FUNCTION: Opener._previousWindow() {{{1 -function! s:Opener._previousWindow() - if !nerdtree#isWindowUsable(winnr("#")) && nerdtree#firstUsableWindow() ==# -1 - call self._newSplit() - else - try - if !nerdtree#isWindowUsable(winnr("#")) - call nerdtree#exec(nerdtree#firstUsableWindow() . "wincmd w") - else - call nerdtree#exec('wincmd p') - endif - catch /^Vim\%((\a\+)\)\=:E37/ - call nerdtree#putCursorInTreeWin() - throw "NERDTree.FileAlreadyOpenAndModifiedError: ". self._path.str() ." is already open and modified." - catch /^Vim\%((\a\+)\)\=:/ - echo v:exception - endtry - endif -endfunction - -"FUNCTION: Opener._restoreCursorPos(){{{1 -function! s:Opener._restoreCursorPos() - call nerdtree#exec('normal ' . self._tabnr . 'gt') - call nerdtree#exec(bufwinnr(self._bufnr) . 'wincmd w') -endfunction - -"FUNCTION: Opener._reuseWindow(){{{1 -"put the cursor in the first window we find for this file -" -"return 1 if we were successful -function! s:Opener._reuseWindow() - "check the current tab for the window - let winnr = bufwinnr('^' . self._path.str() . '$') - if winnr != -1 - call nerdtree#exec(winnr . "wincmd w") - call self._checkToCloseTree(0) - return 1 - else - "check other tabs - let tabnr = self._path.tabnr() - if tabnr - call self._checkToCloseTree(1) - call nerdtree#exec('normal! ' . tabnr . 'gt') - let winnr = bufwinnr('^' . self._path.str() . '$') - call nerdtree#exec(winnr . "wincmd w") - return 1 - endif - endif - return 0 -endfunction - -"FUNCTION: Opener._saveCursorPos(){{{1 -function! s:Opener._saveCursorPos() - let self._bufnr = bufnr("") - let self._tabnr = tabpagenr() -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/path.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/path.vim deleted file mode 100644 index 58bb013..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/path.vim +++ /dev/null @@ -1,724 +0,0 @@ -"we need to use this number many times for sorting... so we calculate it only -"once here -let s:NERDTreeSortStarIndex = index(g:NERDTreeSortOrder, '*') - -"CLASS: Path -"============================================================ -let s:Path = {} -let g:NERDTreePath = s:Path - -"FUNCTION: Path.AbsolutePathFor(str) {{{1 -function! s:Path.AbsolutePathFor(str) - let prependCWD = 0 - if nerdtree#runningWindows() - let prependCWD = a:str !~# '^.:\(\\\|\/\)' && a:str !~# '^\(\\\\\|\/\/\)' - else - let prependCWD = a:str !~# '^/' - endif - - let toReturn = a:str - if prependCWD - let toReturn = getcwd() . s:Path.Slash() . a:str - endif - - return toReturn -endfunction - -"FUNCTION: Path.bookmarkNames() {{{1 -function! s:Path.bookmarkNames() - if !exists("self._bookmarkNames") - call self.cacheDisplayString() - endif - return self._bookmarkNames -endfunction - -"FUNCTION: Path.cacheDisplayString() {{{1 -function! s:Path.cacheDisplayString() - let self.cachedDisplayString = self.getLastPathComponent(1) - - if self.isExecutable - let self.cachedDisplayString = self.cachedDisplayString . '*' - endif - - let self._bookmarkNames = [] - for i in g:NERDTreeBookmark.Bookmarks() - if i.path.equals(self) - call add(self._bookmarkNames, i.name) - endif - endfor - if !empty(self._bookmarkNames) - let self.cachedDisplayString .= ' {' . join(self._bookmarkNames) . '}' - endif - - if self.isSymLink - let self.cachedDisplayString .= ' -> ' . self.symLinkDest - endif - - if self.isReadOnly - let self.cachedDisplayString .= ' [RO]' - endif -endfunction - -"FUNCTION: Path.changeToDir() {{{1 -function! s:Path.changeToDir() - let dir = self.str({'format': 'Cd'}) - if self.isDirectory ==# 0 - let dir = self.getParent().str({'format': 'Cd'}) - endif - - try - execute "cd " . dir - call nerdtree#echo("CWD is now: " . getcwd()) - catch - throw "NERDTree.PathChangeError: cannot change CWD to " . dir - endtry -endfunction - -"FUNCTION: Path.compareTo() {{{1 -" -"Compares this Path to the given path and returns 0 if they are equal, -1 if -"this Path is "less than" the given path, or 1 if it is "greater". -" -"Args: -"path: the path object to compare this to -" -"Return: -"1, -1 or 0 -function! s:Path.compareTo(path) - let thisPath = self.getLastPathComponent(1) - let thatPath = a:path.getLastPathComponent(1) - - "if the paths are the same then clearly we return 0 - if thisPath ==# thatPath - return 0 - endif - - let thisSS = self.getSortOrderIndex() - let thatSS = a:path.getSortOrderIndex() - - "compare the sort sequences, if they are different then the return - "value is easy - if thisSS < thatSS - return -1 - elseif thisSS > thatSS - return 1 - else - "if the sort sequences are the same then compare the paths - "alphabetically - let pathCompare = g:NERDTreeCaseSensitiveSort ? thisPath <# thatPath : thisPath limit - let toReturn = "<" . strpart(toReturn, len(toReturn) - limit + 1) - endif - endif - - return toReturn -endfunction - -"FUNCTION: Path._strForUI() {{{1 -function! s:Path._strForUI() - let toReturn = '/' . join(self.pathSegments, '/') - if self.isDirectory && toReturn != '/' - let toReturn = toReturn . '/' - endif - return toReturn -endfunction - -"FUNCTION: Path._strForCd() {{{1 -" -" returns a string that can be used with :cd -function! s:Path._strForCd() - return escape(self.str(), nerdtree#escChars()) -endfunction - -"FUNCTION: Path._strForEdit() {{{1 -" -"Return: the string for this path that is suitable to be used with the :edit -"command -function! s:Path._strForEdit() - let p = escape(self.str({'format': 'UI'}), nerdtree#escChars()) - let cwd = getcwd() . s:Path.Slash() - - "return a relative path if we can - let isRelative = 0 - if nerdtree#runningWindows() - let isRelative = stridx(tolower(p), tolower(cwd)) == 0 - else - let isRelative = stridx(p, cwd) == 0 - endif - - if isRelative - let p = strpart(p, strlen(cwd)) - - "handle the edge case where the file begins with a + (vim interprets - "the +foo in `:e +foo` as an option to :edit) - if p[0] == "+" - let p = '\' . p - endif - endif - - if p ==# '' - let p = '.' - endif - - return p -endfunction - -"FUNCTION: Path._strForGlob() {{{1 -function! s:Path._strForGlob() - let lead = s:Path.Slash() - - "if we are running windows then slap a drive letter on the front - if nerdtree#runningWindows() - let lead = self.drive . '\' - endif - - let toReturn = lead . join(self.pathSegments, s:Path.Slash()) - - if !nerdtree#runningWindows() - let toReturn = escape(toReturn, nerdtree#escChars()) - endif - return toReturn -endfunction - -"FUNCTION: Path._str() {{{1 -" -"Gets the string path for this path object that is appropriate for the OS. -"EG, in windows c:\foo\bar -" in *nix /foo/bar -function! s:Path._str() - let lead = s:Path.Slash() - - "if we are running windows then slap a drive letter on the front - if nerdtree#runningWindows() - let lead = self.drive . '\' - endif - - return lead . join(self.pathSegments, s:Path.Slash()) -endfunction - -"FUNCTION: Path.strTrunk() {{{1 -"Gets the path without the last segment on the end. -function! s:Path.strTrunk() - return self.drive . '/' . join(self.pathSegments[0:-2], '/') -endfunction - -" FUNCTION: Path.tabnr() {{{1 -" return the number of the first tab that is displaying this file -" -" return 0 if no tab was found -function! s:Path.tabnr() - let str = self.str() - for t in range(tabpagenr('$')) - for b in tabpagebuflist(t+1) - if str == expand('#' . b . ':p') - return t+1 - endif - endfor - endfor - return 0 -endfunction - -"FUNCTION: Path.WinToUnixPath(pathstr){{{1 -"Takes in a windows path and returns the unix equiv -" -"A class level method -" -"Args: -"pathstr: the windows path to convert -function! s:Path.WinToUnixPath(pathstr) - if !nerdtree#runningWindows() - return a:pathstr - endif - - let toReturn = a:pathstr - - "remove the x:\ of the front - let toReturn = substitute(toReturn, '^.*:\(\\\|/\)\?', '/', "") - - "remove the \\ network share from the front - let toReturn = substitute(toReturn, '^\(\\\\\|\/\/\)[^\\\/]*\(\\\|\/\)[^\\\/]*\(\\\|\/\)\?', '/', "") - - "convert all \ chars to / - let toReturn = substitute(toReturn, '\', '/', "g") - - return toReturn -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/tree_dir_node.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/tree_dir_node.vim deleted file mode 100644 index 1b1a231..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/tree_dir_node.vim +++ /dev/null @@ -1,528 +0,0 @@ -"CLASS: TreeDirNode -"A subclass of NERDTreeFileNode. -" -"The 'composite' part of the file/dir composite. -"============================================================ -let s:TreeDirNode = copy(g:NERDTreeFileNode) -let g:NERDTreeDirNode = s:TreeDirNode - -"FUNCTION: TreeDirNode.AbsoluteTreeRoot(){{{1 -"class method that returns the highest cached ancestor of the current root -function! s:TreeDirNode.AbsoluteTreeRoot() - let currentNode = b:NERDTreeRoot - while currentNode.parent != {} - let currentNode = currentNode.parent - endwhile - return currentNode -endfunction - -"FUNCTION: TreeDirNode.activate([options]) {{{1 -unlet s:TreeDirNode.activate -function! s:TreeDirNode.activate(...) - let opts = a:0 ? a:1 : {} - call self.toggleOpen(opts) - call nerdtree#renderView() - call self.putCursorHere(0, 0) -endfunction - -"FUNCTION: TreeDirNode.addChild(treenode, inOrder) {{{1 -"Adds the given treenode to the list of children for this node -" -"Args: -"-treenode: the node to add -"-inOrder: 1 if the new node should be inserted in sorted order -function! s:TreeDirNode.addChild(treenode, inOrder) - call add(self.children, a:treenode) - let a:treenode.parent = self - - if a:inOrder - call self.sortChildren() - endif -endfunction - -"FUNCTION: TreeDirNode.close() {{{1 -"Closes this directory -function! s:TreeDirNode.close() - let self.isOpen = 0 -endfunction - -"FUNCTION: TreeDirNode.closeChildren() {{{1 -"Closes all the child dir nodes of this node -function! s:TreeDirNode.closeChildren() - for i in self.children - if i.path.isDirectory - call i.close() - call i.closeChildren() - endif - endfor -endfunction - -"FUNCTION: TreeDirNode.createChild(path, inOrder) {{{1 -"Instantiates a new child node for this node with the given path. The new -"nodes parent is set to this node. -" -"Args: -"path: a Path object that this node will represent/contain -"inOrder: 1 if the new node should be inserted in sorted order -" -"Returns: -"the newly created node -function! s:TreeDirNode.createChild(path, inOrder) - let newTreeNode = g:NERDTreeFileNode.New(a:path) - call self.addChild(newTreeNode, a:inOrder) - return newTreeNode -endfunction - -"FUNCTION: TreeDirNode.findNode(path) {{{1 -"Will find one of the children (recursively) that has the given path -" -"Args: -"path: a path object -unlet s:TreeDirNode.findNode -function! s:TreeDirNode.findNode(path) - if a:path.equals(self.path) - return self - endif - if stridx(a:path.str(), self.path.str(), 0) ==# -1 - return {} - endif - - if self.path.isDirectory - for i in self.children - let retVal = i.findNode(a:path) - if retVal != {} - return retVal - endif - endfor - endif - return {} -endfunction - -"FUNCTION: TreeDirNode.getChildCount() {{{1 -"Returns the number of children this node has -function! s:TreeDirNode.getChildCount() - return len(self.children) -endfunction - -"FUNCTION: TreeDirNode.getChild(path) {{{1 -"Returns child node of this node that has the given path or {} if no such node -"exists. -" -"This function doesnt not recurse into child dir nodes -" -"Args: -"path: a path object -function! s:TreeDirNode.getChild(path) - if stridx(a:path.str(), self.path.str(), 0) ==# -1 - return {} - endif - - let index = self.getChildIndex(a:path) - if index ==# -1 - return {} - else - return self.children[index] - endif - -endfunction - -"FUNCTION: TreeDirNode.getChildByIndex(indx, visible) {{{1 -"returns the child at the given index -"Args: -"indx: the index to get the child from -"visible: 1 if only the visible children array should be used, 0 if all the -"children should be searched. -function! s:TreeDirNode.getChildByIndex(indx, visible) - let array_to_search = a:visible? self.getVisibleChildren() : self.children - if a:indx > len(array_to_search) - throw "NERDTree.InvalidArgumentsError: Index is out of bounds." - endif - return array_to_search[a:indx] -endfunction - -"FUNCTION: TreeDirNode.getChildIndex(path) {{{1 -"Returns the index of the child node of this node that has the given path or -"-1 if no such node exists. -" -"This function doesnt not recurse into child dir nodes -" -"Args: -"path: a path object -function! s:TreeDirNode.getChildIndex(path) - if stridx(a:path.str(), self.path.str(), 0) ==# -1 - return -1 - endif - - "do a binary search for the child - let a = 0 - let z = self.getChildCount() - while a < z - let mid = (a+z)/2 - let diff = a:path.compareTo(self.children[mid].path) - - if diff ==# -1 - let z = mid - elseif diff ==# 1 - let a = mid+1 - else - return mid - endif - endwhile - return -1 -endfunction - -"FUNCTION: TreeDirNode.GetSelected() {{{1 -"Returns the current node if it is a dir node, or else returns the current -"nodes parent -unlet s:TreeDirNode.GetSelected -function! s:TreeDirNode.GetSelected() - let currentDir = g:NERDTreeFileNode.GetSelected() - if currentDir != {} && !currentDir.isRoot() - if currentDir.path.isDirectory ==# 0 - let currentDir = currentDir.parent - endif - endif - return currentDir -endfunction - -"FUNCTION: TreeDirNode.getVisibleChildCount() {{{1 -"Returns the number of visible children this node has -function! s:TreeDirNode.getVisibleChildCount() - return len(self.getVisibleChildren()) -endfunction - -"FUNCTION: TreeDirNode.getVisibleChildren() {{{1 -"Returns a list of children to display for this node, in the correct order -" -"Return: -"an array of treenodes -function! s:TreeDirNode.getVisibleChildren() - let toReturn = [] - for i in self.children - if i.path.ignore() ==# 0 - call add(toReturn, i) - endif - endfor - return toReturn -endfunction - -"FUNCTION: TreeDirNode.hasVisibleChildren() {{{1 -"returns 1 if this node has any childre, 0 otherwise.. -function! s:TreeDirNode.hasVisibleChildren() - return self.getVisibleChildCount() != 0 -endfunction - -"FUNCTION: TreeDirNode._initChildren() {{{1 -"Removes all childen from this node and re-reads them -" -"Args: -"silent: 1 if the function should not echo any "please wait" messages for -"large directories -" -"Return: the number of child nodes read -function! s:TreeDirNode._initChildren(silent) - "remove all the current child nodes - let self.children = [] - - "get an array of all the files in the nodes dir - let dir = self.path - let globDir = dir.str({'format': 'Glob'}) - - if version >= 703 - let filesStr = globpath(globDir, '*', 1) . "\n" . globpath(globDir, '.*', 1) - else - let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*') - endif - - let files = split(filesStr, "\n") - - if !a:silent && len(files) > g:NERDTreeNotificationThreshold - call nerdtree#echo("Please wait, caching a large dir ...") - endif - - let invalidFilesFound = 0 - for i in files - - "filter out the .. and . directories - "Note: we must match .. AND ../ cos sometimes the globpath returns - "../ for path with strange chars (eg $) - if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$' - - "put the next file in a new node and attach it - try - let path = g:NERDTreePath.New(i) - call self.createChild(path, 0) - catch /^NERDTree.\(InvalidArguments\|InvalidFiletype\)Error/ - let invalidFilesFound += 1 - endtry - endif - endfor - - call self.sortChildren() - - if !a:silent && len(files) > g:NERDTreeNotificationThreshold - call nerdtree#echo("Please wait, caching a large dir ... DONE (". self.getChildCount() ." nodes cached).") - endif - - if invalidFilesFound - call nerdtree#echoWarning(invalidFilesFound . " file(s) could not be loaded into the NERD tree") - endif - return self.getChildCount() -endfunction - -"FUNCTION: TreeDirNode.New(path) {{{1 -"Returns a new TreeNode object with the given path and parent -" -"Args: -"path: a path object representing the full filesystem path to the file/dir that the node represents -unlet s:TreeDirNode.New -function! s:TreeDirNode.New(path) - if a:path.isDirectory != 1 - throw "NERDTree.InvalidArgumentsError: A TreeDirNode object must be instantiated with a directory Path object." - endif - - let newTreeNode = copy(self) - let newTreeNode.path = a:path - - let newTreeNode.isOpen = 0 - let newTreeNode.children = [] - - let newTreeNode.parent = {} - - return newTreeNode -endfunction - -"FUNCTION: TreeDirNode.open([opts]) {{{1 -"Open the dir in the current tree or in a new tree elsewhere. -" -"If opening in the current tree, return the number of cached nodes. -unlet s:TreeDirNode.open -function! s:TreeDirNode.open(...) - let opts = a:0 ? a:1 : {} - - if has_key(opts, 'where') && !empty(opts['where']) - let opener = g:NERDTreeOpener.New(self.path, opts) - call opener.open(self) - else - let self.isOpen = 1 - if self.children ==# [] - return self._initChildren(0) - else - return 0 - endif - endif -endfunction - -"FUNCTION: TreeDirNode.openAlong([opts]) {{{1 -"recursive open the dir if it has only one directory child. -" -"return the level of opened directories. -function! s:TreeDirNode.openAlong(...) - let opts = a:0 ? a:1 : {} - let level = 0 - - let node = self - while node.path.isDirectory - call node.open(opts) - let level += 1 - if node.getVisibleChildCount() == 1 - let node = node.getChildByIndex(0, 1) - else - break - endif - endwhile - return level -endfunction - -" FUNCTION: TreeDirNode.openExplorer() {{{1 -" opens an explorer window for this node in the previous window (could be a -" nerd tree or a netrw) -function! s:TreeDirNode.openExplorer() - call self.open({'where': 'p'}) -endfunction - -"FUNCTION: TreeDirNode.openInNewTab(options) {{{1 -unlet s:TreeDirNode.openInNewTab -function! s:TreeDirNode.openInNewTab(options) - call nerdtree#deprecated('TreeDirNode.openInNewTab', 'is deprecated, use open() instead') - call self.open({'where': 't'}) -endfunction - -"FUNCTION: TreeDirNode._openInNewTab() {{{1 -function! s:TreeDirNode._openInNewTab() - tabnew - call g:NERDTreeCreator.CreatePrimary(self.path.str()) -endfunction - -"FUNCTION: TreeDirNode.openRecursively() {{{1 -"Opens this treenode and all of its children whose paths arent 'ignored' -"because of the file filters. -" -"This method is actually a wrapper for the OpenRecursively2 method which does -"the work. -function! s:TreeDirNode.openRecursively() - call self._openRecursively2(1) -endfunction - -"FUNCTION: TreeDirNode._openRecursively2() {{{1 -"Opens this all children of this treenode recursively if either: -" *they arent filtered by file filters -" *a:forceOpen is 1 -" -"Args: -"forceOpen: 1 if this node should be opened regardless of file filters -function! s:TreeDirNode._openRecursively2(forceOpen) - if self.path.ignore() ==# 0 || a:forceOpen - let self.isOpen = 1 - if self.children ==# [] - call self._initChildren(1) - endif - - for i in self.children - if i.path.isDirectory ==# 1 - call i._openRecursively2(0) - endif - endfor - endif -endfunction - -"FUNCTION: TreeDirNode.refresh() {{{1 -unlet s:TreeDirNode.refresh -function! s:TreeDirNode.refresh() - call self.path.refresh() - - "if this node was ever opened, refresh its children - if self.isOpen || !empty(self.children) - "go thru all the files/dirs under this node - let newChildNodes = [] - let invalidFilesFound = 0 - let dir = self.path - let globDir = dir.str({'format': 'Glob'}) - let filesStr = globpath(globDir, '*') . "\n" . globpath(globDir, '.*') - let files = split(filesStr, "\n") - for i in files - "filter out the .. and . directories - "Note: we must match .. AND ../ cos sometimes the globpath returns - "../ for path with strange chars (eg $) - if i !~# '\/\.\.\/\?$' && i !~# '\/\.\/\?$' - - try - "create a new path and see if it exists in this nodes children - let path = g:NERDTreePath.New(i) - let newNode = self.getChild(path) - if newNode != {} - call newNode.refresh() - call add(newChildNodes, newNode) - - "the node doesnt exist so create it - else - let newNode = g:NERDTreeFileNode.New(path) - let newNode.parent = self - call add(newChildNodes, newNode) - endif - - - catch /^NERDTree.InvalidArgumentsError/ - let invalidFilesFound = 1 - endtry - endif - endfor - - "swap this nodes children out for the children we just read/refreshed - let self.children = newChildNodes - call self.sortChildren() - - if invalidFilesFound - call nerdtree#echoWarning("some files could not be loaded into the NERD tree") - endif - endif -endfunction - -"FUNCTION: TreeDirNode.reveal(path) {{{1 -"reveal the given path, i.e. cache and open all treenodes needed to display it -"in the UI -function! s:TreeDirNode.reveal(path) - if !a:path.isUnder(self.path) - throw "NERDTree.InvalidArgumentsError: " . a:path.str() . " should be under " . self.path.str() - endif - - call self.open() - - if self.path.equals(a:path.getParent()) - let n = self.findNode(a:path) - call nerdtree#renderView() - call n.putCursorHere(1,0) - return - endif - - let p = a:path - while !p.getParent().equals(self.path) - let p = p.getParent() - endwhile - - let n = self.findNode(p) - call n.reveal(a:path) -endfunction - -"FUNCTION: TreeDirNode.removeChild(treenode) {{{1 -" -"Removes the given treenode from this nodes set of children -" -"Args: -"treenode: the node to remove -" -"Throws a NERDTree.ChildNotFoundError if the given treenode is not found -function! s:TreeDirNode.removeChild(treenode) - for i in range(0, self.getChildCount()-1) - if self.children[i].equals(a:treenode) - call remove(self.children, i) - return - endif - endfor - - throw "NERDTree.ChildNotFoundError: child node was not found" -endfunction - -"FUNCTION: TreeDirNode.sortChildren() {{{1 -" -"Sorts the children of this node according to alphabetical order and the -"directory priority. -" -function! s:TreeDirNode.sortChildren() - let CompareFunc = function("nerdtree#compareNodes") - call sort(self.children, CompareFunc) -endfunction - -"FUNCTION: TreeDirNode.toggleOpen([options]) {{{1 -"Opens this directory if it is closed and vice versa -function! s:TreeDirNode.toggleOpen(...) - let opts = a:0 ? a:1 : {} - if self.isOpen ==# 1 - call self.close() - else - if g:NERDTreeCasadeOpenSingleChildDir == 0 - call self.open(opts) - else - call self.openAlong(opts) - endif - endif -endfunction - -"FUNCTION: TreeDirNode.transplantChild(newNode) {{{1 -"Replaces the child of this with the given node (where the child node's full -"path matches a:newNode's fullpath). The search for the matching node is -"non-recursive -" -"Arg: -"newNode: the node to graft into the tree -function! s:TreeDirNode.transplantChild(newNode) - for i in range(0, self.getChildCount()-1) - if self.children[i].equals(a:newNode) - let self.children[i] = a:newNode - let a:newNode.parent = self - break - endif - endfor -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/plugin/nerdtree/tree_file_node.vim b/common/.vim/bundle/nerdtree/plugin/nerdtree/tree_file_node.vim deleted file mode 100644 index ab8d371..0000000 --- a/common/.vim/bundle/nerdtree/plugin/nerdtree/tree_file_node.vim +++ /dev/null @@ -1,485 +0,0 @@ -"CLASS: TreeFileNode -"This class is the parent of the TreeDirNode class and is the -"'Component' part of the composite design pattern between the treenode -"classes. -"============================================================ -let s:TreeFileNode = {} -let g:NERDTreeFileNode = s:TreeFileNode - -"FUNCTION: TreeFileNode.activate(...) {{{1 -function! s:TreeFileNode.activate(...) - call self.open(a:0 ? a:1 : {}) -endfunction - -"FUNCTION: TreeFileNode.bookmark(name) {{{1 -"bookmark this node with a:name -function! s:TreeFileNode.bookmark(name) - - "if a bookmark exists with the same name and the node is cached then save - "it so we can update its display string - let oldMarkedNode = {} - try - let oldMarkedNode = g:NERDTreeBookmark.GetNodeForName(a:name, 1) - catch /^NERDTree.BookmarkNotFoundError/ - catch /^NERDTree.BookmarkedNodeNotFoundError/ - endtry - - call g:NERDTreeBookmark.AddBookmark(a:name, self.path) - call self.path.cacheDisplayString() - call g:NERDTreeBookmark.Write() - - if !empty(oldMarkedNode) - call oldMarkedNode.path.cacheDisplayString() - endif -endfunction - -"FUNCTION: TreeFileNode.cacheParent() {{{1 -"initializes self.parent if it isnt already -function! s:TreeFileNode.cacheParent() - if empty(self.parent) - let parentPath = self.path.getParent() - if parentPath.equals(self.path) - throw "NERDTree.CannotCacheParentError: already at root" - endif - let self.parent = s:TreeFileNode.New(parentPath) - endif -endfunction - -"FUNCTION: TreeFileNode.clearBookmarks() {{{1 -function! s:TreeFileNode.clearBookmarks() - for i in g:NERDTreeBookmark.Bookmarks() - if i.path.equals(self.path) - call i.delete() - end - endfor - call self.path.cacheDisplayString() -endfunction - -"FUNCTION: TreeFileNode.copy(dest) {{{1 -function! s:TreeFileNode.copy(dest) - call self.path.copy(a:dest) - let newPath = g:NERDTreePath.New(a:dest) - let parent = b:NERDTreeRoot.findNode(newPath.getParent()) - if !empty(parent) - call parent.refresh() - return parent.findNode(newPath) - else - return {} - endif -endfunction - -"FUNCTION: TreeFileNode.delete {{{1 -"Removes this node from the tree and calls the Delete method for its path obj -function! s:TreeFileNode.delete() - call self.path.delete() - call self.parent.removeChild(self) -endfunction - -"FUNCTION: TreeFileNode.displayString() {{{1 -" -"Returns a string that specifies how the node should be represented as a -"string -" -"Return: -"a string that can be used in the view to represent this node -function! s:TreeFileNode.displayString() - return self.path.displayString() -endfunction - -"FUNCTION: TreeFileNode.equals(treenode) {{{1 -" -"Compares this treenode to the input treenode and returns 1 if they are the -"same node. -" -"Use this method instead of == because sometimes when the treenodes contain -"many children, vim seg faults when doing == -" -"Args: -"treenode: the other treenode to compare to -function! s:TreeFileNode.equals(treenode) - return self.path.str() ==# a:treenode.path.str() -endfunction - -"FUNCTION: TreeFileNode.findNode(path) {{{1 -"Returns self if this node.path.Equals the given path. -"Returns {} if not equal. -" -"Args: -"path: the path object to compare against -function! s:TreeFileNode.findNode(path) - if a:path.equals(self.path) - return self - endif - return {} -endfunction - -"FUNCTION: TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) {{{1 -" -"Finds the next sibling for this node in the indicated direction. This sibling -"must be a directory and may/may not have children as specified. -" -"Args: -"direction: 0 if you want to find the previous sibling, 1 for the next sibling -" -"Return: -"a treenode object or {} if no appropriate sibling could be found -function! s:TreeFileNode.findOpenDirSiblingWithVisibleChildren(direction) - "if we have no parent then we can have no siblings - if self.parent != {} - let nextSibling = self.findSibling(a:direction) - - while nextSibling != {} - if nextSibling.path.isDirectory && nextSibling.hasVisibleChildren() && nextSibling.isOpen - return nextSibling - endif - let nextSibling = nextSibling.findSibling(a:direction) - endwhile - endif - - return {} -endfunction - -"FUNCTION: TreeFileNode.findSibling(direction) {{{1 -" -"Finds the next sibling for this node in the indicated direction -" -"Args: -"direction: 0 if you want to find the previous sibling, 1 for the next sibling -" -"Return: -"a treenode object or {} if no sibling could be found -function! s:TreeFileNode.findSibling(direction) - "if we have no parent then we can have no siblings - if self.parent != {} - - "get the index of this node in its parents children - let siblingIndx = self.parent.getChildIndex(self.path) - - if siblingIndx != -1 - "move a long to the next potential sibling node - let siblingIndx = a:direction ==# 1 ? siblingIndx+1 : siblingIndx-1 - - "keep moving along to the next sibling till we find one that is valid - let numSiblings = self.parent.getChildCount() - while siblingIndx >= 0 && siblingIndx < numSiblings - - "if the next node is not an ignored node (i.e. wont show up in the - "view) then return it - if self.parent.children[siblingIndx].path.ignore() ==# 0 - return self.parent.children[siblingIndx] - endif - - "go to next node - let siblingIndx = a:direction ==# 1 ? siblingIndx+1 : siblingIndx-1 - endwhile - endif - endif - - return {} -endfunction - -"FUNCTION: TreeFileNode.getLineNum(){{{1 -"returns the line number this node is rendered on, or -1 if it isnt rendered -function! s:TreeFileNode.getLineNum() - "if the node is the root then return the root line no. - if self.isRoot() - return s:TreeFileNode.GetRootLineNum() - endif - - let totalLines = line("$") - - "the path components we have matched so far - let pathcomponents = [substitute(b:NERDTreeRoot.path.str({'format': 'UI'}), '/ *$', '', '')] - "the index of the component we are searching for - let curPathComponent = 1 - - let fullpath = self.path.str({'format': 'UI'}) - - - let lnum = s:TreeFileNode.GetRootLineNum() - while lnum > 0 - let lnum = lnum + 1 - "have we reached the bottom of the tree? - if lnum ==# totalLines+1 - return -1 - endif - - let curLine = getline(lnum) - - let indent = nerdtree#indentLevelFor(curLine) - if indent ==# curPathComponent - let curLine = nerdtree#stripMarkupFromLine(curLine, 1) - - let curPath = join(pathcomponents, '/') . '/' . curLine - if stridx(fullpath, curPath, 0) ==# 0 - if fullpath ==# curPath || strpart(fullpath, len(curPath)-1,1) ==# '/' - let curLine = substitute(curLine, '/ *$', '', '') - call add(pathcomponents, curLine) - let curPathComponent = curPathComponent + 1 - - if fullpath ==# curPath - return lnum - endif - endif - endif - endif - endwhile - return -1 -endfunction - -"FUNCTION: TreeFileNode.GetRootForTab(){{{1 -"get the root node for this tab -function! s:TreeFileNode.GetRootForTab() - if nerdtree#treeExistsForTab() - return getbufvar(t:NERDTreeBufName, 'NERDTreeRoot') - end - return {} -endfunction - -"FUNCTION: TreeFileNode.GetRootLineNum(){{{1 -"gets the line number of the root node -function! s:TreeFileNode.GetRootLineNum() - let rootLine = 1 - while getline(rootLine) !~# '^\(/\|<\)' - let rootLine = rootLine + 1 - endwhile - return rootLine -endfunction - -"FUNCTION: TreeFileNode.GetSelected() {{{1 -"gets the treenode that the cursor is currently over -function! s:TreeFileNode.GetSelected() - try - let path = nerdtree#getPath(line(".")) - if path ==# {} - return {} - endif - return b:NERDTreeRoot.findNode(path) - catch /^NERDTree/ - return {} - endtry -endfunction - -"FUNCTION: TreeFileNode.isVisible() {{{1 -"returns 1 if this node should be visible according to the tree filters and -"hidden file filters (and their on/off status) -function! s:TreeFileNode.isVisible() - return !self.path.ignore() -endfunction - -"FUNCTION: TreeFileNode.isRoot() {{{1 -"returns 1 if this node is b:NERDTreeRoot -function! s:TreeFileNode.isRoot() - if !nerdtree#treeExistsForBuf() - throw "NERDTree.NoTreeError: No tree exists for the current buffer" - endif - - return self.equals(b:NERDTreeRoot) -endfunction - -"FUNCTION: TreeFileNode.makeRoot() {{{1 -"Make this node the root of the tree -function! s:TreeFileNode.makeRoot() - if self.path.isDirectory - let b:NERDTreeRoot = self - else - call self.cacheParent() - let b:NERDTreeRoot = self.parent - endif - - call b:NERDTreeRoot.open() - - "change dir to the dir of the new root if instructed to - if g:NERDTreeChDirMode ==# 2 - exec "cd " . b:NERDTreeRoot.path.str({'format': 'Edit'}) - endif - - silent doautocmd User NERDTreeNewRoot -endfunction - -"FUNCTION: TreeFileNode.New(path) {{{1 -"Returns a new TreeNode object with the given path and parent -" -"Args: -"path: a path object representing the full filesystem path to the file/dir that the node represents -function! s:TreeFileNode.New(path) - if a:path.isDirectory - return g:NERDTreeDirNode.New(a:path) - else - let newTreeNode = copy(self) - let newTreeNode.path = a:path - let newTreeNode.parent = {} - return newTreeNode - endif -endfunction - -"FUNCTION: TreeFileNode.open() {{{1 -function! s:TreeFileNode.open(...) - let opts = a:0 ? a:1 : {} - let opener = g:NERDTreeOpener.New(self.path, opts) - call opener.open(self) -endfunction - -"FUNCTION: TreeFileNode.openSplit() {{{1 -"Open this node in a new window -function! s:TreeFileNode.openSplit() - call nerdtree#deprecated('TreeFileNode.openSplit', 'is deprecated, use .open() instead.') - call self.open({'where': 'h'}) -endfunction - -"FUNCTION: TreeFileNode.openVSplit() {{{1 -"Open this node in a new vertical window -function! s:TreeFileNode.openVSplit() - call nerdtree#deprecated('TreeFileNode.openVSplit', 'is deprecated, use .open() instead.') - call self.open({'where': 'v'}) -endfunction - -"FUNCTION: TreeFileNode.openInNewTab(options) {{{1 -function! s:TreeFileNode.openInNewTab(options) - echomsg 'TreeFileNode.openInNewTab is deprecated' - call self.open(extend({'where': 't'}, a:options)) -endfunction - -"FUNCTION: TreeFileNode.putCursorHere(isJump, recurseUpward){{{1 -"Places the cursor on the line number this node is rendered on -" -"Args: -"isJump: 1 if this cursor movement should be counted as a jump by vim -"recurseUpward: try to put the cursor on the parent if the this node isnt -"visible -function! s:TreeFileNode.putCursorHere(isJump, recurseUpward) - let ln = self.getLineNum() - if ln != -1 - if a:isJump - mark ' - endif - call cursor(ln, col(".")) - else - if a:recurseUpward - let node = self - while node != {} && node.getLineNum() ==# -1 - let node = node.parent - call node.open() - endwhile - call nerdtree#renderView() - call node.putCursorHere(a:isJump, 0) - endif - endif -endfunction - -"FUNCTION: TreeFileNode.refresh() {{{1 -function! s:TreeFileNode.refresh() - call self.path.refresh() -endfunction - -"FUNCTION: TreeFileNode.rename() {{{1 -"Calls the rename method for this nodes path obj -function! s:TreeFileNode.rename(newName) - let newName = substitute(a:newName, '\(\\\|\/\)$', '', '') - call self.path.rename(newName) - call self.parent.removeChild(self) - - let parentPath = self.path.getParent() - let newParent = b:NERDTreeRoot.findNode(parentPath) - - if newParent != {} - call newParent.createChild(self.path, 1) - call newParent.refresh() - endif -endfunction - -"FUNCTION: TreeFileNode.renderToString {{{1 -"returns a string representation for this tree to be rendered in the view -function! s:TreeFileNode.renderToString() - return self._renderToString(0, 0, [], self.getChildCount() ==# 1) -endfunction - -"Args: -"depth: the current depth in the tree for this call -"drawText: 1 if we should actually draw the line for this node (if 0 then the -"child nodes are rendered only) -"vertMap: a binary array that indicates whether a vertical bar should be draw -"for each depth in the tree -"isLastChild:true if this curNode is the last child of its parent -function! s:TreeFileNode._renderToString(depth, drawText, vertMap, isLastChild) - let output = "" - if a:drawText ==# 1 - - let treeParts = '' - - "get all the leading spaces and vertical tree parts for this line - if a:depth > 1 - for j in a:vertMap[0:-2] - if g:NERDTreeDirArrows - let treeParts = treeParts . ' ' - else - if j ==# 1 - let treeParts = treeParts . '| ' - else - let treeParts = treeParts . ' ' - endif - endif - endfor - endif - - "get the last vertical tree part for this line which will be different - "if this node is the last child of its parent - if !g:NERDTreeDirArrows - if a:isLastChild - let treeParts = treeParts . '`' - else - let treeParts = treeParts . '|' - endif - endif - - "smack the appropriate dir/file symbol on the line before the file/dir - "name itself - if self.path.isDirectory - if self.isOpen - if g:NERDTreeDirArrows - let treeParts = treeParts . '▾ ' - else - let treeParts = treeParts . '~' - endif - else - if g:NERDTreeDirArrows - let treeParts = treeParts . '▸ ' - else - let treeParts = treeParts . '+' - endif - endif - else - if g:NERDTreeDirArrows - let treeParts = treeParts . ' ' - else - let treeParts = treeParts . '-' - endif - endif - let line = treeParts . self.displayString() - - let output = output . line . "\n" - endif - - "if the node is an open dir, draw its children - if self.path.isDirectory ==# 1 && self.isOpen ==# 1 - - let childNodesToDraw = self.getVisibleChildren() - if len(childNodesToDraw) > 0 - - "draw all the nodes children except the last - let lastIndx = len(childNodesToDraw)-1 - if lastIndx > 0 - for i in childNodesToDraw[0:lastIndx-1] - let output = output . i._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 1), 0) - endfor - endif - - "draw the last child, indicating that it IS the last - let output = output . childNodesToDraw[lastIndx]._renderToString(a:depth + 1, 1, add(copy(a:vertMap), 0), 1) - endif - endif - - return output -endfunction - -" vim: set sw=4 sts=4 et fdm=marker: diff --git a/common/.vim/bundle/nerdtree/syntax/nerdtree.vim b/common/.vim/bundle/nerdtree/syntax/nerdtree.vim deleted file mode 100644 index 636d2af..0000000 --- a/common/.vim/bundle/nerdtree/syntax/nerdtree.vim +++ /dev/null @@ -1,88 +0,0 @@ -let s:tree_up_dir_line = '.. (up a dir)' -"NERDTreeFlags are syntax items that should be invisible, but give clues as to -"how things should be highlighted -syn match NERDTreeFlag #\~# -syn match NERDTreeFlag #\[RO\]# - -"highlighting for the .. (up dir) line at the top of the tree -execute "syn match NERDTreeUp #\\V". s:tree_up_dir_line ."#" - -"highlighting for the ~/+ symbols for the directory nodes -syn match NERDTreeClosable #\~\<# -syn match NERDTreeClosable #\~\.# -syn match NERDTreeOpenable #+\<# -syn match NERDTreeOpenable #+\.#he=e-1 - -"highlighting for the tree structural parts -syn match NERDTreePart #|# -syn match NERDTreePart #`# -syn match NERDTreePartFile #[|`]-#hs=s+1 contains=NERDTreePart - -"quickhelp syntax elements -syn match NERDTreeHelpKey #" \{1,2\}[^ ]*:#hs=s+2,he=e-1 -syn match NERDTreeHelpKey #" \{1,2\}[^ ]*,#hs=s+2,he=e-1 -syn match NERDTreeHelpTitle #" .*\~#hs=s+2,he=e-1 contains=NERDTreeFlag -syn match NERDTreeToggleOn #".*(on)#hs=e-2,he=e-1 contains=NERDTreeHelpKey -syn match NERDTreeToggleOff #".*(off)#hs=e-3,he=e-1 contains=NERDTreeHelpKey -syn match NERDTreeHelpCommand #" :.\{-}\>#hs=s+3 -syn match NERDTreeHelp #^".*# contains=NERDTreeHelpKey,NERDTreeHelpTitle,NERDTreeFlag,NERDTreeToggleOff,NERDTreeToggleOn,NERDTreeHelpCommand - -"highlighting for readonly files -syn match NERDTreeRO #.*\[RO\]#hs=s+2 contains=NERDTreeFlag,NERDTreeBookmark,NERDTreePart,NERDTreePartFile - -"highlighting for sym links -syn match NERDTreeLink #[^-| `].* -> # contains=NERDTreeBookmark,NERDTreeOpenable,NERDTreeClosable,NERDTreeDirSlash - -"highlighing for directory nodes and file nodes -syn match NERDTreeDirSlash #/# -syn match NERDTreeDir #[^-| `].*/# contains=NERDTreeLink,NERDTreeDirSlash,NERDTreeOpenable,NERDTreeClosable -syn match NERDTreeExecFile #[|` ].*\*\($\| \)# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark -syn match NERDTreeFile #|-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile -syn match NERDTreeFile #`-.*# contains=NERDTreeLink,NERDTreePart,NERDTreeRO,NERDTreePartFile,NERDTreeBookmark,NERDTreeExecFile -syn match NERDTreeCWD #^[# -syn match NERDTreeBookmarksHeader #^>-\+Bookmarks-\+$# contains=NERDTreeBookmarksLeader -syn match NERDTreeBookmarkName #^>.\{-} #he=e-1 contains=NERDTreeBookmarksLeader -syn match NERDTreeBookmark #^>.*$# contains=NERDTreeBookmarksLeader,NERDTreeBookmarkName,NERDTreeBookmarksHeader - -if exists("g:NERDChristmasTree") && g:NERDChristmasTree - hi def link NERDTreePart Special - hi def link NERDTreePartFile Type - hi def link NERDTreeFile Normal - hi def link NERDTreeExecFile Title - hi def link NERDTreeDirSlash Identifier - hi def link NERDTreeClosable Type -else - hi def link NERDTreePart Normal - hi def link NERDTreePartFile Normal - hi def link NERDTreeFile Normal - hi def link NERDTreeClosable Title -endif - -hi def link NERDTreeBookmarksHeader statement -hi def link NERDTreeBookmarksLeader ignore -hi def link NERDTreeBookmarkName Identifier -hi def link NERDTreeBookmark normal - -hi def link NERDTreeHelp String -hi def link NERDTreeHelpKey Identifier -hi def link NERDTreeHelpCommand Identifier -hi def link NERDTreeHelpTitle Macro -hi def link NERDTreeToggleOn Question -hi def link NERDTreeToggleOff WarningMsg - -hi def link NERDTreeDir Directory -hi def link NERDTreeUp Directory -hi def link NERDTreeCWD Statement -hi def link NERDTreeLink Macro -hi def link NERDTreeOpenable Title -hi def link NERDTreeFlag ignore -hi def link NERDTreeRO WarningMsg -hi def link NERDTreeBookmark Statement - -hi def link NERDTreeCurrentNode Search diff --git a/common/.vim/closetag.vim b/common/.vim/closetag.vim deleted file mode 100644 index 6ce41fb..0000000 --- a/common/.vim/closetag.vim +++ /dev/null @@ -1,327 +0,0 @@ -" File: closetag.vim -" Summary: Functions and mappings to close open HTML/XML tags -" Uses: -- close matching open tag -" Author: Steven Mueller -" Last Modified: Tue May 24 13:29:48 PDT 2005 -" Version: 0.9.1 -" XXX - breaks if close attempted while XIM is in preedit mode -" TODO - allow usability as a global plugin - -" Add g:unaryTagsStack - always contains html tags settings -" and g:closetag_default_xml - user should define this to default to xml -" When a close is attempted but b:unaryTagsStack undefined, -" use b:closetag_html_style to determine if the file is to be treated -" as html or xml. Failing that, check the filetype for xml or html. -" Finally, default to g:closetag_html_style. -" If the file is html, let b:unaryTagsStack=g:unaryTagsStack -" otherwise, let b:unaryTagsStack="" -" TODO - make matching work for all comments -" -- kinda works now, but needs syn sync minlines to be very long -" -- Only check whether in syntax in the beginning, then store comment tags -" in the tagstacks to determine whether to move into or out of comment mode -" TODO - The new normal mode mapping clears recent messages with its , and -" it doesn't fix the null-undo issue for vim 5.7 anyway. -" TODO - make use of the following neat features: -" -- the ternary ?: operator -" -- :echomsg and :echoerr -" -- curly brace expansion for variables and function name definitions? -" -- check up on map \FuncName -" -" Description: -" This script eases redundant typing when writing html or xml files (even if -" you're very good with ctrl-p and ctrl-n :). Hitting ctrl-_ will initiate a -" search for the most recent open tag above that is not closed in the -" intervening space and then insert the matching close tag at the cursor. In -" normal mode, the close tag is inserted one character after cursor rather than -" at it, as if a had been used. This allows putting close tags at the -" ends of lines while in normal mode, but disallows inserting them in the -" first column. -" -" For HTML, a configurable list of tags are ignored in the matching process. -" By default, the following tags will not be matched and thus not closed -" automatically: area, base, br, dd, dt, hr, img, input, link, meta, and -" param. -" -" For XML, all tags must have a closing match or be terminated by />, as in -" . These empty element tags are ignored for matching. -" -" Comment checking is now handled by vim's internal syntax checking. If tag -" closing is initiated outside a comment, only tags outside of comments will -" be matched. When closing tags in comments, only tags within comments will -" be matched, skipping any non-commented out code (wee!). However, the -" process of determining the syntax ID of an arbitrary position can still be -" erroneous if a comment is not detected because the syntax highlighting is -" out of sync, or really slow if syn sync minlines is large. -" Set the b:closetag_disable_synID variable to disable this feature if you -" have really big chunks of comment in your code and closing tags is too slow. -" -" If syntax highlighting is not enabled, comments will not be handled very -" well. Commenting out HTML in certain ways may cause a "tag mismatch" -" message and no completion. For example, '' -" between the cursor and the most recent unclosed open tag above causes -" trouble. Properly matched well formed tags in comments don't cause a -" problem. -" -" Install: -" To use, place this file in your standard vim scripts directory, and source -" it while editing the file you wish to close tags in. If the filetype is not -" set or the file is some sort of template with embedded HTML, you may force -" HTML style tag matching by first defining the b:closetag_html_style buffer -" variable. Otherwise, the default is XML style tag matching. -" -" Example: -" :let b:closetag_html_style=1 -" :source ~/.vim/scripts/closetag.vim -" -" For greater convenience, load this script in an autocommand: -" :au Filetype html,xml,xsl source ~/.vim/scripts/closetag.vim -" -" Also, set noignorecase for html files or edit b:unaryTagsStack to match your -" capitalization style. You may set this variable before or after loading the -" script, or simply change the file itself. -" -" Configuration Variables: -" -" b:unaryTagsStack Buffer local string containing a whitespace -" seperated list of element names that should be -" ignored while finding matching closetags. Checking -" is done according to the current setting of the -" ignorecase option. -" -" b:closetag_html_style Define this (as with let b:closetag_html_style=1) -" and source the script again to set the -" unaryTagsStack to its default value for html. -" -" b:closetag_disable_synID Define this to disable comment checking if tag -" closing is too slow. This can be set or unset -" without having to source again. -" -" Changelog: -" May 24, 2005 Tuesday -" * Changed function names to be script-local to avoid conflicts with other -" scripts' stack implementations. -" -" June 07, 2001 Thursday -" * Added comment handling. Currently relies on synID, so if syn sync -" minlines is small, the chance for failure is high, but if minlines is -" large, tagclosing becomes rather slow... -" -" * Changed normal mode closetag mapping to use in insert mode -" rather than p in normal mode. This has 2 implications: -" - Tag closing no longer clobbers the unnamed register -" - When tag closing fails or finds no match, no longer adds to the undo -" buffer for recent vim 6.0 development versions. -" - However, clears the last message when closing tags in normal mode -" -" * Changed the closetag_html_style variable to be buffer-local rather than -" global. -" -" * Expanded documentation - -"------------------------------------------------------------------------------ -" User configurable settings -"------------------------------------------------------------------------------ - -" if html, don't close certain tags. Works best if ignorecase is set. -" otherwise, capitalize these elements according to your html editing style -if !exists("b:unaryTagsStack") || exists("b:closetag_html_style") - if &filetype == "html" || exists("b:closetag_html_style") - let b:unaryTagsStack="area base br dd dt hr img input link meta param" - else " for xsl and xsl - let b:unaryTagsStack="" - endif -endif - -" Has this already been loaded? -if exists("loaded_closetag") - finish -endif -let loaded_closetag=1 - -" set up mappings for tag closing -inoremap =GetCloseTag() -map a - -"------------------------------------------------------------------------------ -" Tag closer - uses the stringstack implementation below -"------------------------------------------------------------------------------ - -" Returns the most recent unclosed tag-name -" (ignores tags in the variable referenced by a:unaryTagsStack) -function! GetLastOpenTag(unaryTagsStack) - " Search backwards through the file line by line using getline() - " Overall strategy (moving backwards through the file from the cursor): - " Push closing tags onto a stack. - " On an opening tag, if the tag matches the stack top, discard both. - " -- if the tag doesn't match, signal an error. - " -- if the stack is empty, use this tag - let linenum=line(".") - let lineend=col(".") - 1 " start: cursor position - let first=1 " flag for first line searched - let b:TagStack="" " main stack of tags - let startInComment=s:InComment() - - let tagpat='' - " Search for: closing tags - while (linenum>0) - " Every time we see an end-tag, we push it on the stack. When we see an - " open tag, if the stack isn't empty, we pop it and see if they match. - " If no, signal an error. - " If yes, continue searching backwards. - " If stack is empty, return this open tag as the one that needs closing. - let line=getline(linenum) - if first - let line=strpart(line,0,lineend) - else - let lineend=strlen(line) - endif - let b:lineTagStack="" - let mpos=0 - let b:TagCol=0 - " Search the current line in the forward direction, pushing any tags - " onto a special stack for the current line - while (mpos > -1) - let mpos=matchend(line,tagpat) - if mpos > -1 - let b:TagCol=b:TagCol+mpos - let tag=matchstr(line,tagpat) - - if exists("b:closetag_disable_synID") || startInComment==s:InCommentAt(linenum, b:TagCol) - let b:TagLine=linenum - call s:Push(matchstr(tag,'[^<>]\+'),"b:lineTagStack") - endif - "echo "Tag: ".tag." ending at position ".mpos." in '".line."'." - let lineend=lineend-mpos - let line=strpart(line,mpos,lineend) - endif - endwhile - " Process the current line stack - while (!s:EmptystackP("b:lineTagStack")) - let tag=s:Pop("b:lineTagStack") - if match(tag, "^/") == 0 "found end tag - call s:Push(tag,"b:TagStack") - "echo linenum." ".b:TagStack - elseif s:EmptystackP("b:TagStack") && !s:Instack(tag, a:unaryTagsStack) "found unclosed tag - return tag - else - let endtag=s:Peekstack("b:TagStack") - if endtag == "/".tag || endtag == "/" - call s:Pop("b:TagStack") "found a open/close tag pair - "echo linenum." ".b:TagStack - elseif !s:Instack(tag, a:unaryTagsStack) "we have a mismatch error - echohl Error - echon "\rError:" - echohl None - echo " tag mismatch: <".tag."> doesn't match <".endtag.">. (Line ".linenum." Tagstack: ".b:TagStack.")" - return "" - endif - endif - endwhile - let linenum=linenum-1 | let first=0 - endwhile - " At this point, we have exhausted the file and not found any opening tag - echo "No opening tags." - return "" -endfunction - -" Returns closing tag for most recent unclosed tag, respecting the -" current setting of b:unaryTagsStack for tags that should not be closed -function! GetCloseTag() - let tag=GetLastOpenTag("b:unaryTagsStack") - if tag == "" - return "" - else - return "" - endif -endfunction - -" return 1 if the cursor is in a syntactically identified comment field -" (fails for empty lines: always returns not-in-comment) -function! s:InComment() - return synIDattr(synID(line("."), col("."), 0), "name") =~ 'Comment' -endfunction - -" return 1 if the position specified is in a syntactically identified comment field -function! s:InCommentAt(line, col) - return synIDattr(synID(a:line, a:col, 0), "name") =~ 'Comment' -endfunction - -"------------------------------------------------------------------------------ -" String Stacks -"------------------------------------------------------------------------------ -" These are strings of whitespace-separated elements, matched using the \< and -" \> patterns after setting the iskeyword option. -" -" The sname argument should contain a symbolic reference to the stack variable -" on which method should operate on (i.e., sname should be a string containing -" a fully qualified (ie: g:, b:, etc) variable name.) - -" Helper functions -function! s:SetKeywords() - let g:IsKeywordBak=&iskeyword - let &iskeyword="33-255" -endfunction - -function! s:RestoreKeywords() - let &iskeyword=g:IsKeywordBak -endfunction - -" Push el onto the stack referenced by sname -function! s:Push(el, sname) - if !s:EmptystackP(a:sname) - exe "let ".a:sname."=a:el.' '.".a:sname - else - exe "let ".a:sname."=a:el" - endif -endfunction - -" Check whether the stack is empty -function! s:EmptystackP(sname) - exe "let stack=".a:sname - if match(stack,"^ *$") == 0 - return 1 - else - return 0 - endif -endfunction - -" Return 1 if el is in stack sname, else 0. -function! s:Instack(el, sname) - exe "let stack=".a:sname - call s:SetKeywords() - let m=match(stack, "\\<".a:el."\\>") - call s:RestoreKeywords() - if m < 0 - return 0 - else - return 1 - endif -endfunction - -" Return the first element in the stack -function! s:Peekstack(sname) - call s:SetKeywords() - exe "let stack=".a:sname - let top=matchstr(stack, "\\<.\\{-1,}\\>") - call s:RestoreKeywords() - return top -endfunction - -" Remove and return the first element in the stack -function! s:Pop(sname) - if s:EmptystackP(a:sname) - echo "Error! Stack ".a:sname." is empty and can't be popped." - return "" - endif - exe "let stack=".a:sname - " Find the first space, loc is 0-based. Marks the end of 1st elt in stack. - call s:SetKeywords() - let loc=matchend(stack,"\\<.\\{-1,}\\>") - exe "let ".a:sname."=strpart(stack, loc+1, strlen(stack))" - let top=strpart(stack, match(stack, "\\<"), loc) - call s:RestoreKeywords() - return top -endfunction - -function! s:Clearstack(sname) - exe "let ".a:sname."=''" -endfunction diff --git a/common/.vimrc b/common/.vimrc index 7e42ba9..b2562d4 100644 --- a/common/.vimrc +++ b/common/.vimrc @@ -27,6 +27,8 @@ set encoding=utf-8 set nocompatible " désactivation de la compatibilité avec vi +set shortmess+=filmnrxoOtT " retire le hit + colorscheme distinguished " couleur set background=dark " fond noir par défaut "hi CursorLine guibg=#606060 " couleur de la ligne de curseur @@ -78,6 +80,12 @@ set foldcolumn=6 " colonne de replis(fold colding) set viminfo='10,\"100,:20,%,n~/.viminfo au BufReadPost * if line("'\"") > 0|if line("'\"") <= line("$")|exe("norm '\"")|else|exe "norm $"|endif|endif +"""""""""""""""""""""""""""""""""""""""""""""""""" +"Appel des bundles avec pathogen +"""""""""""""""""""""""""""""""""""""""""""""""""" +runtime! autoload/pathogen.vim +silent! call pathogen#helptags() +silent! call pathogen#runtime_append_all_bundles() """""""""""""""""""""""""""""""""""""""""""""""""" @@ -106,18 +114,18 @@ imap :set noexpandtab "Sauvegarde automatique des vues, utiles pour les "replis manuels """""""""""""""""""""""""""""""""""""""""""""""""" -au BufWinLeave *.html mkview -au BufWinEnter *.html silent loadview -au BufWinLeave *.css mkview -au BufWinEnter *.css silent loadview -au BufWinLeave *.php mkview -au BufWinEnter *.php silent loadview -au BufWinLeave *.js mkview -au BufWinEnter *.js silent loadview -au BufWinLeave *.py mkview -au BufWinEnter *.py silent loadview -au BufWinLeave *.java mkview -au BufWinEnter *.java silent loadview +"au BufWinLeave *.html mkview +"au BufWinEnter *.html silent loadview +"au BufWinLeave *.css mkview +"au BufWinEnter *.css silent loadview +"au BufWinLeave *.php mkview +"au BufWinEnter *.php silent loadview +"au BufWinLeave *.js mkview +"au BufWinEnter *.js silent loadview +"au BufWinLeave *.py mkview +"au BufWinEnter *.py silent loadview +"au BufWinLeave *.java mkview +"au BufWinEnter *.java silent loadview """""""""""""""""""""""""""""""""""""""""""""""" "Options du fichier de syntaxe python @@ -209,3 +217,5 @@ if ! has('gui_running') au InsertLeave * set timeoutlen=1000 augroup END endif + +let g:jedi#autocompletion_command = "" diff --git a/common/.zshrc b/common/.zshrc index 1e6d472..38eb87d 100644 --- a/common/.zshrc +++ b/common/.zshrc @@ -100,4 +100,3 @@ hisoka() { ssc hisoka.kujiu.org ${argv[-1]:-`whoami`} 22 $argv[1,-2]; hl() { highlight --out-format=xterm256 -l ${argv} | less -R; } bindkey "^[[A" history-search-backward bindkey "^[[B" history-search-forward - diff --git a/update-home.sh b/update-home.sh index 5a788de..27e0368 100755 --- a/update-home.sh +++ b/update-home.sh @@ -1,13 +1,75 @@ #!/usr/bin/env bash +# Remove zsh completion dump +rm ~/.zcompdump + +# Remove vim config directory +rm -rf ~/.vim-backup +mv ~/.vim ~/.vim-backup +mkdir -p ~/.vim/{autoload,bundle,colors,doc,ftplugin,plugin,spell,syntax} + +# Install oh-my-zsh rm -rf ~/.oh-my-zsh git clone git://github.com/robbyrussell/oh-my-zsh.git ~/.oh-my-zsh +# Copy the graphical part if needed if [ "$1" == '--graphic' ] then rsync -av graphic/ ~/ fc-cache -vf ~/.fonts fi +# Copy the common part rsync -av common/ ~/ + +# Adjust the tmux conf sed -i "s/REPLACEMEWITHFIRSTLETTEROFHOSTNAME/`expr substr \`hostname\` 1 1`/g" ~/.tmux.conf + +######### VIM Config ########### + +# Install pathogen + +curl -Sso ~/.vim/autoload/pathogen.vim https://raw.github.com/tpope/vim-pathogen/master/autoload/pathogen.vim + +# Install jedi plugin for vim +rm -rf ~/.vim/bundle/jedi +git clone https://github.com/davidhalter/jedi-vim.git ~/.vim/bundle/jedi + +# Install nerdtree for vim +rm -rf ~/.vim/bundle/nerdtree +git clone https://github.com/scrooloose/nerdtree.git ~/.vim/bundle/nerdtree + +# Install xmledit for vim +rm -rf ~/.vim/bundle/xmledit +git clone https://github.com/sukima/xmledit.git ~/.vim/bundle/xmledit +pushd ~/.vim/bundle/xmledit +make install +popd + +# Install pyflakes plugin +rm -rf ~/.vim/bundle/pyflakes +git clone --recursive git://github.com/kevinw/pyflakes-vim.git ~/.vim/bundle/pyflakes + +# Install autoclose plugin +rm -rf ~/.vim/bundle/autoclose +git clone https://github.com/Townk/vim-autoclose.git ~/.vim/bundle/autoclose + +# Install tagbar plugin +rm -rf ~/.vim/bundle/tagbar +git clone https://github.com/majutsushi/tagbar ~/.vim/bundle/tagbar + +# Install vcscommand plugin +rm -rf ~/.vim/bundle/vcscommand +git clone https://github.com/vim-scripts/vcscommand.vim.git ~/.vim/bundle/vcscommand + +# Install easytag plugin +rm -rf ~/.vim/bundle/easytag +git clone https://github.com/vim-scripts/easytags.vim.git ~/.vim/bundle/easytag + +# Install closetag plugin +rm -rf ~/.vim/bundle/closetag +git clone https://github.com/vim-scripts/closetag.vim.git ~/.vim/bundle/closetag + +# Install css3 syntax +rm -rf ~/.vim/bundle/css3-mod +git clone https://github.com/vim-scripts/css3-mod.git ~/.vim/bundle/css3-mod

    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�lrR5pu5*1w%*CXA03u=r@LWw!>vY&e4AJ{J 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 {cnM$qiHXC)LEJz|s%s;|_}<@n?k>3M7fo&Y+CE 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 z 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 z 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