finish

defaults/main.yml

@@ -2,3 +2,8 @@
 # defaults file for init
 allow_password: false
 hypervisor: false
+mirror_debian: http://deb.debian.org
+mirror_debian_security: http://security.debian.org
+mirror_ubuntu: http://archive.ubuntu.com
+mirror_ubuntu_security: http://security.ubuntu.com
+china_mirror: false

files/.vim/after/ftplugin/python_pydiction.vim

+" ============================================================================
+" python_pydiction.vim - Module and Keyword completion for Python
+" ============================================================================
+"
+" Author: Ryan Kulla (rkulla AT gmail DOT com)
+" Version: 1.2, for Vim 7
+" URL: http://www.vim.org/scripts/script.php?script_id=850
+" Last Modified: July 22th, 2009
+" Installation: On Linux, put this file in ~/.vim/after/ftplugin/
+"               On Windows, put this file in C:\vim\vimfiles\ftplugin\
+"                        (assuming you installed vim in C:\vim\).
+"               You may install the other files anywhere. 
+"               In .vimrc, add the following:
+"                   filetype plugin on
+"                   let g:pydiction_location = 'path/to/complete-dict'
+"               Optionally, you set the completion menu height like:
+"                   let g:pydiction_menu_height = 20
+"               The default menu height is 15
+"               To do case-sensitive searches, set noignorecase (:set noic).
+" Usage: Type part of a Python keyword, module name, attribute or method,
+"        then hit the TAB key and it will auto-complete (as long as it 
+"        exists in the complete-dict file.
+"        You can also use Shift-Tab to Tab backwards.
+" License: BSD
+" Copyright: Copyright (c) 2003-2009 Ryan Kulla
+"            All rights reserved.
+"
+"            Redistribution and use in source and binary forms, with or without
+"            modification, are permitted provided that the following conditions
+"            are met:
+"            1. Redistributions of source code must retain the above copyright
+"               notice, this list of conditions and the following disclaimer.
+"            2. Redistributions in binary form must reproduce the above
+"               copyright notice, this list of conditions and the following
+"               disclaimer in the documentation and/or other materials provided
+"               with the distribution.
+"            3. The name of the author may not be used to endorse or promote 
+"               products derived from this software without specific prior 
+"               written permission.
+"
+"            THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+"            OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+"            WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+"            ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+"            DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+"            DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+"            GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+"            INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+"            WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+"            NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+"            THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"
+"
+
+if v:version < 700
+    echoerr "Pydiction requires vim version 7 or greater."
+    finish
+endif
+
+
+" Make the Tab key do python code completion:
+inoremap <silent> <buffer> <Tab> 
+         \<C-R>=<SID>SetVals()<CR>
+         \<C-R>=<SID>TabComplete('down')<CR>
+         \<C-R>=<SID>RestoreVals()<CR>
+
+" Make Shift+Tab do python code completion in the reverse direction:
+inoremap <silent> <buffer> <S-Tab> 
+         \<C-R>=<SID>SetVals()<CR>
+         \<C-R>=<SID>TabComplete('up')<CR>
+         \<C-R>=<SID>RestoreVals()<CR>
+
+
+if !exists("*s:TabComplete")
+    function! s:TabComplete(direction)
+        " Check if the char before the char under the cursor is an 
+        " underscore, letter, number, dot or opening parentheses.
+        " If it is, and if the popup menu is not visible, use 
+        " I_CTRL-X_CTRL-K ('dictionary' only completion)--otherwise, 
+        " use I_CTRL-N to scroll downward through the popup menu or
+        " use I_CTRL-P to scroll upward through the popup menu, 
+        " depending on the value of a:direction.
+        " If the char is some other character, insert a normal Tab:
+        if searchpos('[_a-zA-Z0-9.(]\%#', 'nb') != [0, 0] 
+            if !pumvisible()
+                return "\<C-X>\<C-K>"
+            else
+                if a:direction == 'down'
+                    return "\<C-N>"
+                else
+                    return "\<C-P>"
+                endif
+            endif
+        else
+            return "\<Tab>"
+        endif
+    endfunction
+endif
+
+
+if !exists("*s:SetVals") 
+    function! s:SetVals()
+        " Save and change any config values we need.
+
+        " Temporarily change isk to treat periods and opening 
+        " parenthesis as part of a keyword -- so we can complete
+        " python modules and functions:
+        let s:pydiction_save_isk = &iskeyword
+        setlocal iskeyword +=.,(
+
+        " Save any current dictionaries the user has set:
+        let s:pydiction_save_dictions = &dictionary
+        " Temporarily use only pydiction's dictionary:
+        let &dictionary = g:pydiction_location
+
+        " Save the ins-completion options the user has set:
+        let s:pydiction_save_cot = &completeopt
+        " Have the completion menu show up for one or more matches:
+        let &completeopt = "menu,menuone"
+
+        " Set the popup menu height:
+        let s:pydiction_save_pumheight = &pumheight
+        if !exists('g:pydiction_menu_height')
+            let g:pydiction_menu_height = 15
+        endif
+        let &pumheight = g:pydiction_menu_height
+
+        return ''
+    endfunction
+endif
+
+
+if !exists("*s:RestoreVals")
+    function! s:RestoreVals()
+        " Restore the user's initial values.
+
+        let &dictionary = s:pydiction_save_dictions
+        let &completeopt = s:pydiction_save_cot
+        let &pumheight = s:pydiction_save_pumheight
+        let &iskeyword = s:pydiction_save_isk
+
+        return ''
+    endfunction
+endif
+

files/.vim/after/plugin/snipMate.vim

+" These are the mappings for snipMate.vim. Putting it here ensures that it
+" will be mapped after other plugins such as supertab.vim.
+if !exists('loaded_snips') || exists('s:did_snips_mappings')
+	finish
+endif
+let s:did_snips_mappings = 1
+
+ino <silent> <tab> <c-r>=TriggerSnippet()<cr>
+snor <silent> <tab> <esc>i<right><c-r>=TriggerSnippet()<cr>
+ino <silent> <s-tab> <c-r>=BackwardsSnippet()<cr>
+snor <silent> <s-tab> <esc>i<right><c-r>=BackwardsSnippet()<cr>
+ino <silent> <c-r><tab> <c-r>=ShowAvailableSnips()<cr>
+
+" The default mappings for these are annoying & sometimes break snipMate.
+" You can change them back if you want, I've put them here for convenience.
+snor <bs> b<bs>
+snor <right> <esc>a
+snor <left> <esc>bi
+snor ' b<bs>'
+snor ` b<bs>`
+snor % b<bs>%
+snor U b<bs>U
+snor ^ b<bs>^
+snor \ b<bs>\
+snor <c-x> b<bs><c-x>
+
+" By default load snippets in snippets_dir
+if empty(snippets_dir)
+	finish
+endif
+
+call GetSnippets(snippets_dir, '_') " Get global snippets
+
+au FileType * if &ft != 'help' | call GetSnippets(snippets_dir, &ft) | endif
+" vim:noet:sw=4:ts=4:ft=vim

files/.vim/after/pydiction.py

+#!/usr/bin/env python
+# Last modified: July 23rd, 2009
+"""
+
+pydiction.py 1.2 by Ryan Kulla (rkulla AT gmail DOT com).
+
+Description: Creates a Vim dictionary of Python module attributes for Vim's 
+             completion feature.  The created dictionary file is used by
+             the Vim ftplugin "python_pydiction.vim".
+
+Usage: pydiction.py <module> ... [-v]
+Example: The following will append all the "time" and "math" modules'
+         attributes to a file, in the current directory, called "pydiction"
+         with and without the "time." and "math." prefix:
+             $ python pydiction.py time math
+         To print the output just to stdout, instead of appending to the file, 
+         supply the -v option: 
+             $ python pydiction.py -v time math
+
+License: BSD.
+"""
+
+
+__author__ = "Ryan Kulla (rkulla AT gmail DOT com)"
+__version__ = "1.2"
+__copyright__ = "Copyright (c) 2003-2009 Ryan Kulla"
+
+
+import os
+import sys
+import types
+import shutil
+
+
+# Path/filename of the vim dictionary file to write to:
+PYDICTION_DICT = r'complete-dict'
+# Path/filename of the vim dictionary backup file:
+PYDICTION_DICT_BACKUP = r'complete-dict.last'
+
+# Sentintal to test if we should only output to stdout:
+STDOUT_ONLY = False
+
+
+def get_submodules(module_name, submodules):
+    """Build a list of all the submodules of modules."""
+
+    # Try to import a given module, so we can dir() it:
+    try:
+        imported_module = my_import(module_name)
+    except ImportError, err:
+        return submodules
+
+    mod_attrs = dir(imported_module)
+
+    for mod_attr in mod_attrs:
+        if type(getattr(imported_module, mod_attr)) is types.ModuleType:
+            submodules.append(module_name + '.' + mod_attr)
+
+    return submodules
+
+
+def write_dictionary(module_name):
+    """Write to module attributes to the vim dictionary file."""
+    prefix_on = '%s.%s'
+    prefix_on_callable = '%s.%s('
+    prefix_off = '%s'
+    prefix_off_callable = '%s('
+
+    try:
+        imported_module = my_import(module_name)
+    except ImportError, err:
+        return
+
+    mod_attrs = dir(imported_module)
+
+    # Generate fully-qualified module names: 
+    write_to.write('\n--- import %s ---\n' % module_name)
+    for mod_attr in mod_attrs:
+        if callable(getattr(imported_module, mod_attr)):
+            # If an attribute is callable, show an opening parentheses:
+            format = prefix_on_callable
+        else:
+            format = prefix_on
+        write_to.write(format % (module_name, mod_attr) + '\n')
+
+    # Generate submodule names by themselves, for when someone does
+    # "from foo import bar" and wants to complete bar.baz.
+    # This works the same no matter how many .'s are in the module.
+    if module_name.count('.'):
+        # Get the "from" part of the module. E.g., 'xml.parsers'
+        # if the module name was 'xml.parsers.expat':
+        first_part = module_name[:module_name.rfind('.')]
+        # Get the "import" part of the module. E.g., 'expat'
+        # if the module name was 'xml.parsers.expat'
+        second_part = module_name[module_name.rfind('.') + 1:]
+        write_to.write('\n--- from %s import %s ---\n' % 
+                       (first_part, second_part))
+        for mod_attr in mod_attrs:
+            if callable(getattr(imported_module, mod_attr)):
+                format = prefix_on_callable
+            else:
+                format = prefix_on
+            write_to.write(format % (second_part, mod_attr) + '\n')
+
+    # Generate non-fully-qualified module names: 
+    write_to.write('\n--- from %s import * ---\n' % module_name)
+    for mod_attr in mod_attrs:
+        if callable(getattr(imported_module, mod_attr)):
+            format = prefix_off_callable
+        else:
+            format = prefix_off
+        write_to.write(format % mod_attr + '\n')
+
+
+def my_import(name):
+    """Make __import__ import "package.module" formatted names."""
+    mod = __import__(name)
+    components = name.split('.')
+    for comp in components[1:]:
+        mod = getattr(mod, comp)
+    return mod
+
+
+def remove_duplicates(seq, keep=()):
+    """
+
+    Remove duplicates from a sequence while perserving order.
+
+    The optional tuple argument "keep" can be given to specificy 
+    each string you don't want to be removed as a duplicate.
+    """
+    seq2 = []
+    seen = set();
+    for i in seq:
+        if i in (keep):
+            seq2.append(i)
+            continue
+        elif i not in seen:
+            seq2.append(i)
+        seen.add(i)
+    return seq2
+
+
+def get_yesno(msg="[Y/n]?"):
+    """
+    
+    Returns True if user inputs 'n', 'Y', "yes", "Yes"...
+    Returns False if user inputs 'n', 'N', "no", "No"...
+    If they enter an invalid option it tells them so and asks again.
+    Hitting Enter is equivalent to answering Yes.
+    Takes an optional message to display, defaults to "[Y/n]?".
+
+    """
+    while True:
+        answer = raw_input(msg)
+        if answer == '':
+            return True
+        elif len(answer):
+            answer = answer.lower()[0]
+            if answer == 'y':
+                return True
+                break
+            elif answer == 'n':
+                return False
+                break
+            else:
+                print "Invalid option. Please try again."
+                continue
+
+
+def main(write_to):
+    """Generate a dictionary for Vim of python module attributes."""
+    submodules = []
+
+    for module_name in sys.argv[1:]:
+        try:
+            imported_module = my_import(module_name)
+        except ImportError, err:
+            print "Couldn't import: %s. %s" % (module_name, err)
+            sys.argv.remove(module_name)
+
+    cli_modules = sys.argv[1:]
+
+    # Step through each command line argument:
+    for module_name in cli_modules:
+        print "Trying module: %s" % module_name
+        submodules = get_submodules(module_name, submodules)
+
+        # Step through the current module's submodules:
+        for submodule_name in submodules:
+            submodules = get_submodules(submodule_name, submodules)
+
+    # Add the top-level modules to the list too:
+    for module_name in cli_modules:
+        submodules.append(module_name)
+
+    submodules.sort()
+
+    # Step through all of the modules and submodules to create the dict file:
+    for submodule_name in submodules:
+        write_dictionary(submodule_name)
+
+    if STDOUT_ONLY:
+        return
+
+    # Close and Reopen the file for reading and remove all duplicate lines:
+    write_to.close()
+    print "Removing duplicates..."
+    f = open(PYDICTION_DICT, 'r')
+    file_lines = f.readlines()
+    file_lines = remove_duplicates(file_lines, ('\n'))
+    f.close()
+
+    # Delete the original file:
+    os.unlink(PYDICTION_DICT)
+    
+    # Recreate the file, this time it won't have any duplicates lines:
+    f = open(PYDICTION_DICT, 'w')
+    for attr in file_lines:
+        f.write(attr)
+    f.close()
+    print "Done."
+
+
+if __name__ == '__main__':
+    """Process the command line."""
+
+    if sys.version_info[0:2] < (2, 3):
+        sys.exit("You need a Python 2.x version of at least Python 2.3")
+
+    if len(sys.argv) <= 1:
+        sys.exit("%s requires at least one argument. None given." % 
+                  sys.argv[0])
+
+    if '-v' in sys.argv:
+        write_to = sys.stdout
+        sys.argv.remove('-v')
+        STDOUT_ONLY = True
+    elif os.path.exists(PYDICTION_DICT):
+            # See if any of the given modules have already been pydiction'd:
+            f = open(PYDICTION_DICT, 'r')
+            file_lines = f.readlines()
+            for module_name in sys.argv[1:]:
+                for line in file_lines:
+                    if line.find('--- import %s ' % module_name) != -1:
+                        print '"%s" already exists in %s. Skipping...' % \
+                               (module_name, PYDICTION_DICT)
+                        sys.argv.remove(module_name)
+                        break
+            f.close()
+
+            if len(sys.argv) < 2:
+                # Check if there's still enough command-line arguments:
+                sys.exit("Nothing new to do. Aborting.")
+            
+            if os.path.exists(PYDICTION_DICT_BACKUP):
+                answer = get_yesno('Overwrite existing backup "%s" [Y/n]? ' % \
+                                    PYDICTION_DICT_BACKUP)
+                if (answer):
+                    print "Backing up old dictionary to: %s" % \
+                           PYDICTION_DICT_BACKUP
+                    try:
+                        shutil.copyfile(PYDICTION_DICT, PYDICTION_DICT_BACKUP)
+                    except IOError, err:
+                        print "Couldn't back up %s. %s" % (PYDICTION_DICT, err)
+                else:
+                    print "Skipping backup..."
+
+                print 'Appending to: "%s"' % PYDICTION_DICT
+            else:
+                print "Backing up current %s to %s" % \
+                       (PYDICTION_DICT, PYDICTION_DICT_BACKUP)
+                try:
+                    shutil.copyfile(PYDICTION_DICT, PYDICTION_DICT_BACKUP)
+                except IOError, err:
+                    print "Couldn't back up %s. %s" % (PYDICTION_DICT, err)
+    else:
+        print 'Creating file: "%s"' % PYDICTION_DICT
+
+
+    if not STDOUT_ONLY:
+        write_to = open(PYDICTION_DICT, 'a')
+
+    main(write_to)

files/.vim/autoload/conque_term/conque_screen.py

+# FILE:     autoload/conque_term/conque_screen.py
+# AUTHOR:   Nico Raffo <nicoraffo@gmail.com>
+# WEBSITE:  http://conque.googlecode.com
+# MODIFIED: 2011-08-12
+# VERSION:  2.2, for Vim 7.0
+# LICENSE:
+# Conque - Vim terminal/console emulator
+# Copyright (C) 2009-__YEAR__ Nico Raffo
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+ConqueScreen is an extention of the vim.current.buffer object
+
+Unix terminal escape sequences usually reference line numbers relative to the 
+top of the visible screen. However the visible portion of the Vim buffer
+representing the terminal probably doesn't start at the first line of the 
+buffer.
+
+The ConqueScreen class allows access to the Vim buffer with screen-relative
+line numbering. And handles a few other related tasks, such as setting the
+correct cursor position.
+
+  E.g.:
+    s = ConqueScreen()
+    ...
+    s[5] = 'Set 5th line in terminal to this line'
+    s.append('Add new line to terminal')
+    s[5] = 'Since previous append() command scrolled the terminal down, this is a different line than first cb[5] call'
+
+"""
+
+import vim
+
+
+class ConqueScreen(object):
+
+    # the buffer
+    buffer = None
+
+    # screen and scrolling regions
+    screen_top = 1
+
+    # screen width
+    screen_width = 80
+    screen_height = 80
+
+    # char encoding for vim buffer
+    screen_encoding = 'utf-8'
+
+
+    def __init__(self):
+        """ Initialize screen size and character encoding. """
+
+        self.buffer = vim.current.buffer
+
+        # initialize screen size
+        self.screen_top = 1
+        self.screen_width = vim.current.window.width
+        self.screen_height = vim.current.window.height
+
+        # save screen character encoding type
+        self.screen_encoding = vim.eval('&fileencoding')
+
+
+    def __len__(self):
+        """ Define the len() function for ConqueScreen objects. """
+        return len(self.buffer)
+
+
+    def __getitem__(self, key):
+        """ Define value access for ConqueScreen objects. """
+        buffer_line = self.get_real_idx(key)
+
+        # if line is past buffer end, add lines to buffer
+        if buffer_line >= len(self.buffer):
+            for i in range(len(self.buffer), buffer_line + 1):
+                self.append(' ')
+
+        return u(self.buffer[buffer_line], 'utf-8')
+
+
+    def __setitem__(self, key, value):
+        """ Define value assignments for ConqueScreen objects. """
+        buffer_line = self.get_real_idx(key)
+
+        if CONQUE_PYTHON_VERSION == 2:
+            val = value.encode(self.screen_encoding)
+        else:
+            # XXX / Vim's python3 interface doesn't accept bytes object
+            val = str(value)
+
+        # if line is past end of screen, append
+        if buffer_line == len(self.buffer):
+            self.buffer.append(val)
+        else:
+            self.buffer[buffer_line] = val
+
+
+    def __delitem__(self, key):
+        """ Define value deletion for ConqueScreen objects. """
+        del self.buffer[self.screen_top + key - 2]
+
+
+    def append(self, value):
+        """ Define value appending for ConqueScreen objects. """
+
+        if len(self.buffer) > self.screen_top + self.screen_height - 1:
+            self.buffer[len(self.buffer) - 1] = value
+        else:
+            self.buffer.append(value)
+
+        if len(self.buffer) > self.screen_top + self.screen_height - 1:
+            self.screen_top += 1
+
+        if vim.current.buffer.number == self.buffer.number:
+            vim.command('normal! G')
+
+
+    def insert(self, line, value):
+        """ Define value insertion for ConqueScreen objects. """
+
+        l = self.screen_top + line - 2
+        self.buffer.append(value, l)
+
+
+    def get_top(self):
+        """ Get the Vim line number representing the top of the visible terminal. """
+        return self.screen_top
+
+
+    def get_real_idx(self, line):
+        """ Get the zero index Vim line number corresponding to the provided screen line. """
+        return (self.screen_top + line - 2)
+
+
+    def get_buffer_line(self, line):
+        """ Get the Vim line number corresponding to the provided screen line. """
+        return (self.screen_top + line - 1)
+
+
+    def set_screen_width(self, width):
+        """ Set the screen width. """
+        self.screen_width = width
+
+
+    def clear(self):
+        """ Clear the screen. Does not clear the buffer, just scrolls down past all text. """
+
+        self.screen_width = width
+        self.buffer.append(' ')
+        vim.command('normal! Gzt')
+        self.screen_top = len(self.buffer)
+
+
+    def set_cursor(self, line, column):
+        """ Set cursor position. """
+
+        # figure out line
+        buffer_line = self.screen_top + line - 1
+        if buffer_line > len(self.buffer):
+            for l in range(len(self.buffer) - 1, buffer_line):
+                self.buffer.append('')
+
+        # figure out column
+        real_column = column
+        if len(self.buffer[buffer_line - 1]) < real_column:
+            self.buffer[buffer_line - 1] = self.buffer[buffer_line - 1] + ' ' * (real_column - len(self.buffer[buffer_line - 1]))
+
+        if not CONQUE_FAST_MODE:
+            # set cursor at byte index of real_column'th character
+            vim.command('call cursor(' + str(buffer_line) + ', byteidx(getline(' + str(buffer_line) + '), ' + str(real_column) + '))')
+
+        else:
+            # old version
+            # python version is occasionally grumpy
+            try:
+                vim.current.window.cursor = (buffer_line, real_column - 1)
+            except:
+                vim.command('call cursor(' + str(buffer_line) + ', ' + str(real_column) + ')')
+
+
+    def reset_size(self, line):
+        """ Change screen size """
+
+
+
+
+
+        # save cursor line number
+        buffer_line = self.screen_top + line
+
+        # reset screen size
+        self.screen_width = vim.current.window.width
+        self.screen_height = vim.current.window.height
+        self.screen_top = len(self.buffer) - vim.current.window.height + 1
+        if self.screen_top < 1:
+            self.screen_top = 1
+
+
+        # align bottom of buffer to bottom of screen
+        vim.command('normal! ' + str(self.screen_height) + 'kG')
+
+        # return new relative line number
+        return (buffer_line - self.screen_top)
+
+
+    def align(self):
+        """ align bottom of buffer to bottom of screen """
+        vim.command('normal! ' + str(self.screen_height) + 'kG')
+
+

files/.vim/autoload/conque_term/conque_sole_communicator.py

+# FILE:     autoload/conque_term/conque_sole_communicator.py
+# AUTHOR:   Nico Raffo <nicoraffo@gmail.com>
+# WEBSITE:  http://conque.googlecode.com
+# MODIFIED: 2011-08-12
+# VERSION:  2.2, for Vim 7.0
+# LICENSE:
+# Conque - Vim terminal/console emulator
+# Copyright (C) 2009-__YEAR__ Nico Raffo
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+
+ConqueSoleCommunicator
+
+This script will create a new Windows console and start the requested program 
+inside of it. This process is launched independently from the parent Vim
+program, so it has no access to the vim module.
+
+The main loop in this script reads data from the console and syncs it onto 
+blocks of memory shared with the Vim process. In this way the Vim process
+and this script can communicate with each other.
+
+"""
+
+import time
+import sys
+
+from conque_globals import *
+from conque_win32_util import *
+from conque_sole_subprocess import *
+from conque_sole_shared_memory import *
+
+##############################################################
+# only run if this file was run directly
+
+if __name__ == '__main__':
+
+    # attempt to catch ALL exceptions to fend of zombies
+    try:
+
+        # simple arg validation
+
+        if len(sys.argv) < 5:
+
+            exit()
+
+        # maximum time this thing reads. 0 means no limit. Only for testing.
+        max_loops = 0
+
+        # read interval, in seconds
+        sleep_time = 0.01
+
+        # idle read interval, in seconds
+        idle_sleep_time = 0.10
+
+        # are we idled?
+        is_idle = False
+
+        # mem key
+        mem_key = sys.argv[1]
+
+        # console width
+        console_width = int(sys.argv[2])
+
+        # console height
+        console_height = int(sys.argv[3])
+
+        # code page
+        code_page = int(sys.argv[4])
+
+        # code page
+        fast_mode = int(sys.argv[5])
+
+        # the actual subprocess to run
+        cmd_line = " ".join(sys.argv[6:])
+
+
+        # width and height
+        options = {'LINES': console_height, 'COLUMNS': console_width, 'CODE_PAGE': code_page, 'FAST_MODE': fast_mode}
+
+
+
+        # set initial idle status
+        shm_command = ConqueSoleSharedMemory(CONQUE_SOLE_COMMANDS_SIZE, 'command', mem_key, serialize=True)
+        shm_command.create('write')
+
+        cmd = shm_command.read()
+        if cmd:
+
+            if cmd['cmd'] == 'idle':
+                is_idle = True
+                shm_command.clear()
+
+
+        ##############################################################
+        # Create the subprocess
+
+        proc = ConqueSoleSubprocess()
+        res = proc.open(cmd_line, mem_key, options)
+
+        if not res:
+
+            exit()
+
+        ##############################################################
+        # main loop!
+
+        loops = 0
+
+        while True:
+
+            # check for idle/resume
+            if is_idle or loops % 25 == 0:
+
+                # check process health
+                if not proc.is_alive():
+
+                    proc.close()
+                    break
+
+                # check for change in buffer focus
+                cmd = shm_command.read()
+                if cmd:
+
+                    if cmd['cmd'] == 'idle':
+                        is_idle = True
+                        shm_command.clear()
+
+                    elif cmd['cmd'] == 'resume':
+                        is_idle = False
+                        shm_command.clear()
+
+
+            # sleep between loops if moderation is requested
+            if sleep_time > 0:
+                if is_idle:
+                    time.sleep(idle_sleep_time)
+                else:
+                    time.sleep(sleep_time)
+
+            # write, read, etc
+            proc.write()
+            proc.read()
+
+            # increment loops, and exit if max has been reached
+            loops += 1
+            if max_loops and loops >= max_loops:
+
+                break
+
+        ##############################################################
+        # all done!
+
+
+
+        proc.close()
+
+    # if an exception was thrown, croak
+    except:
+
+        proc.close()
+
+
+# vim:foldmethod=marker

files/.vim/autoload/conque_term/conque_sole_shared_memory.py

+# FILE:     autoload/conque_term/conque_sole_shared_memory.py
+# AUTHOR:   Nico Raffo <nicoraffo@gmail.com>
+# WEBSITE:  http://conque.googlecode.com
+# MODIFIED: 2011-08-12
+# VERSION:  2.2, for Vim 7.0
+# LICENSE:
+# Conque - Vim terminal/console emulator
+# Copyright (C) 2009-__YEAR__ Nico Raffo
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+"""
+Wrapper class for shared memory between Windows python processes
+
+Adds a small amount of functionality to the standard mmap module.
+
+"""
+
+import mmap
+import sys
+
+# PYTHON VERSION
+CONQUE_PYTHON_VERSION = sys.version_info[0]
+
+if CONQUE_PYTHON_VERSION == 2:
+    import cPickle as pickle
+else:
+    import pickle
+
+
+class ConqueSoleSharedMemory():
+
+    # is the data being stored not fixed length
+    fixed_length = False
+
+    # maximum number of bytes per character, for fixed width blocks
+    char_width = 1
+
+    # fill memory with this character when clearing and fixed_length is true
+    FILL_CHAR = None
+
+    # serialize and unserialize data automatically
+    serialize = False
+
+    # size of shared memory, in bytes / chars
+    mem_size = None
+
+    # size of shared memory, in bytes / chars
+    mem_type = None
+
+    # unique key, so multiple console instances are possible
+    mem_key = None
+
+    # mmap instance
+    shm = None
+
+    # character encoding, dammit
+    encoding = 'utf-8'
+
+    # pickle terminator
+    TERMINATOR = None
+
+
+    def __init__(self, mem_size, mem_type, mem_key, fixed_length=False, fill_char=' ', serialize=False, encoding='utf-8'):
+        """ Initialize new shared memory block instance
+
+        Arguments:
+        mem_size -- Memory size in characters, depends on encoding argument to calcuate byte size
+        mem_type -- Label to identify what will be stored
+        mem_key -- Unique, probably random key to identify this block
+        fixed_length -- If set to true, assume the data stored will always fill the memory size
+        fill_char -- Initialize memory block with this character, only really helpful with fixed_length blocks
+        serialize -- Automatically serialize data passed to write. Allows storing non-byte data
+        encoding -- Character encoding to use when storing character data
+
+        """
+        self.mem_size = mem_size
+        self.mem_type = mem_type
+        self.mem_key = mem_key
+        self.fixed_length = fixed_length
+        self.fill_char = fill_char
+        self.serialize = serialize
+        self.encoding = encoding
+        self.TERMINATOR = str(chr(0)).encode(self.encoding)
+
+        if CONQUE_PYTHON_VERSION == 3:
+            self.FILL_CHAR = fill_char
+        else:
+            self.FILL_CHAR = unicode(fill_char)
+
+        if fixed_length and encoding == 'utf-8':
+            self.char_width = 4
+
+
+    def create(self, access='write'):
+        """ Create a new block of shared memory using the mmap module. """
+
+        if access == 'write':
+            mmap_access = mmap.ACCESS_WRITE
+        else:
+            mmap_access = mmap.ACCESS_READ
+
+        name = "conque_%s_%s" % (self.mem_type, self.mem_key)
+
+        self.shm = mmap.mmap(0, self.mem_size * self.char_width, name, mmap_access)
+
+        if not self.shm:
+            return False
+        else:
+            return True
+
+
+    def read(self, chars=1, start=0):
+        """ Read data from shared memory.
+
+        If this is a fixed length block, read 'chars' characters from memory. 
+        Otherwise read up until the TERMINATOR character (null byte).
+        If this memory is serialized, unserialize it automatically.
+
+        """
+        # go to start position
+        self.shm.seek(start * self.char_width)
+
+        if self.fixed_length:
+            chars = chars * self.char_width
+        else:
+            chars = self.shm.find(self.TERMINATOR)
+
+        if chars == 0:
+            return ''
+
+        shm_str = self.shm.read(chars)
+
+        # return unpickled byte object
+        if self.serialize:
+            return pickle.loads(shm_str)
+
+        # decode byes in python 3
+        if CONQUE_PYTHON_VERSION == 3:
+            return str(shm_str, self.encoding)
+
+        # encoding
+        if self.encoding != 'ascii':
+            shm_str = unicode(shm_str, self.encoding)
+
+        return shm_str
+
+
+    def write(self, text, start=0):
+        """ Write data to memory.
+
+        If memory is fixed length, simply write the 'text' characters at 'start' position.
+        Otherwise write 'text' characters and append a null character.
+        If memory is serializable, do so first.
+
+        """
+        # simple scenario, let pickle create bytes
+        if self.serialize:
+            if CONQUE_PYTHON_VERSION == 3:
+                tb = pickle.dumps(text, 0)
+            else:
+                tb = pickle.dumps(text, 0).encode(self.encoding)
+
+        else:
+            tb = text.encode(self.encoding, 'replace')
+
+        # write to memory
+        self.shm.seek(start * self.char_width)
+
+        if self.fixed_length:
+            self.shm.write(tb)
+        else:
+            self.shm.write(tb + self.TERMINATOR)
+
+
+    def clear(self, start=0):
+        """ Clear memory block using self.fill_char. """
+
+        self.shm.seek(start)
+
+        if self.fixed_length:
+            self.shm.write(str(self.fill_char * self.mem_size * self.char_width).encode(self.encoding))
+        else:
+            self.shm.write(self.TERMINATOR)
+
+
+    def close(self):
+        """ Close/destroy memory block. """
+
+        self.shm.close()
+
+

files/.vim/autoload/zencoding/lang.vim

+let s:exists = {}
+function zencoding#lang#exists(type)
+  if len(a:type) == 0
+    return 0
+  elseif has_key(s:exists, a:type)
+    return s:exists[a:type]
+  endif
+  let s:exists[a:type] = len(globpath(&rtp, 'autoload/zencoding/lang/'.a:type.'.vim')) > 0
+  return s:exists[a:type]
+endfunction
+

files/.vim/bundle/Javascript-OmniCompletion-with-YUI-and-j/README

+This is a mirror of http://www.vim.org/scripts/script.php?script_id=3565
+
+Dav Glass (https://github.com/davglass) started the modification. He added the YUI support, so I've decided to build on top of that foundation.
+
+It far from perfect but it is usable.
+
+Enjoy

files/.vim/bundle/L9/doc/tags-ja

+!_TAG_FILE_ENCODING	utf-8	//
+l9	l9.jax	/*l9*
+l9-about	l9.jax	/*l9-about*
+l9-author	l9.jax	/*l9-author*
+l9-contact	l9.jax	/*l9-contact*
+l9-installation	l9.jax	/*l9-installation*
+l9-introduction	l9.jax	/*l9-introduction*
+l9-usage	l9.jax	/*l9-usage*
+l9.txt	l9.jax	/*l9.txt*

files/.vim/bundle/command-t/.ctags

+--exclude=.git
+--exclude=Makefile
+--exclude=vendor

files/.vim/bundle/command-t/.gitattributes

+data/benchmark.yml export-ignore

files/.vim/bundle/command-t/.gitignore

+.release-notes.txt
+.ruby-version
+/.bundle
+/data/log.yml
+vendor/bundle

files/.vim/bundle/command-t/.rspec

+--colour