Ejemplo n.º 1
0
 def test_pathcompleter_completes_in_current_directory(self):
     completer = PathCompleter()
     doc_text = ''
     doc = Document(doc_text, len(doc_text))
     event = CompleteEvent()
     completions = list(completer.get_completions(doc, event))
     self.assertTrue(len(completions) > 0)
Ejemplo n.º 2
0
 def test_pathcompleter_can_expanduser(self):
     completer = PathCompleter(expanduser=True)
     doc_text = '~'
     doc = Document(doc_text, len(doc_text))
     event = CompleteEvent()
     completions = list(completer.get_completions(doc, event))
     self.assertTrue(len(completions) > 0)
Ejemplo n.º 3
0
    def test_pathcompleter_completes_directories_with_only_directories(self):
        # setup: create a test dir with 10 files
        test_dir = tempfile.mkdtemp()
        write_test_files(test_dir)

        # create a sub directory there
        os.mkdir(os.path.join(test_dir, 'subdir'))

        if not test_dir.endswith(os.path.sep):
            test_dir += os.path.sep

        with chdir(test_dir):
            completer = PathCompleter(only_directories=True)
            doc_text = ''
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = [c.text for c in completions]
            self.assertEqual(['subdir'], result)

        # check that there is no completion when passing a file
        with chdir(test_dir):
            completer = PathCompleter(only_directories=True)
            doc_text = '1'
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            self.assertEqual([], completions)

        # cleanup
        shutil.rmtree(test_dir)
Ejemplo n.º 4
0
 def test_pathcompleter_does_not_expanduser_by_default(self):
     completer = PathCompleter()
     doc_text = '~'
     doc = Document(doc_text, len(doc_text))
     event = CompleteEvent()
     completions = list(completer.get_completions(doc, event))
     self.assertEqual([], completions)
Ejemplo n.º 5
0
 def test_pathcompleter_can_expanduser(self):
     completer = PathCompleter(expanduser=True)
     doc_text = '~'
     doc = Document(doc_text, len(doc_text))
     event = CompleteEvent()
     completions = list(completer.get_completions(doc, event))
     self.assertTrue(len(completions) > 0)
Ejemplo n.º 6
0
    def test_pathcompleter_respects_completions_under_min_input_len(self):
        # setup: create a test dir with 10 files
        test_dir = tempfile.mkdtemp()
        write_test_files(test_dir)

        # min len:1 and no text
        with chdir(test_dir):
            completer = PathCompleter(min_input_len=1)
            doc_text = ''
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            self.assertEqual([], completions)

        # min len:1 and text of len 1
        with chdir(test_dir):
            completer = PathCompleter(min_input_len=1)
            doc_text = '1'
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = [c.text for c in completions]
            self.assertEqual([''], result)

        # min len:0 and text of len 2
        with chdir(test_dir):
            completer = PathCompleter(min_input_len=0)
            doc_text = '1'
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = [c.text for c in completions]
            self.assertEqual([''], result)

        # create 10 files with a 2 char long name
        for i in range(10):
            with open(os.path.join(test_dir, str(i) * 2), 'wb') as out:
                out.write(b'')

        # min len:1 and text of len 1
        with chdir(test_dir):
            completer = PathCompleter(min_input_len=1)
            doc_text = '2'
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = sorted(c.text for c in completions)
            self.assertEqual(['', '2'], result)

        # min len:2 and text of len 1
        with chdir(test_dir):
            completer = PathCompleter(min_input_len=2)
            doc_text = '2'
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            self.assertEqual([], completions)

        # cleanup
        shutil.rmtree(test_dir)
Ejemplo n.º 7
0
def test_pathcompleter_does_not_expanduser_by_default():
    completer = PathCompleter()
    doc_text = '~'
    doc = Document(doc_text, len(doc_text))
    event = CompleteEvent()
    completions = list(completer.get_completions(doc, event))
    assert [] == completions
Ejemplo n.º 8
0
 def test_pathcompleter_completes_in_current_directory(self):
     completer = PathCompleter()
     doc_text = ''
     doc = Document(doc_text, len(doc_text))
     event = CompleteEvent()
     completions = list(completer.get_completions(doc, event))
     self.assertTrue(len(completions) > 0)
Ejemplo n.º 9
0
def test_pathcompleter_can_expanduser(monkeypatch):
    monkeypatch.setenv('HOME', '/tmp')
    completer = PathCompleter(expanduser=True)
    doc_text = '~'
    doc = Document(doc_text, len(doc_text))
    event = CompleteEvent()
    completions = list(completer.get_completions(doc, event))
    assert len(completions) > 0
Ejemplo n.º 10
0
def create_command_completer(editor):
    commands = [c + ' ' for c in get_commands()]

    return GrammarCompleter(COMMAND_GRAMMAR, {
        'command': WordCompleter(commands),
        'location': PathCompleter(expanduser=True),
        'set_option': WordCompleter(sorted(SET_COMMANDS)),
        'buffer_name': BufferNameCompleter(editor),
        'colorscheme': ColorSchemeCompleter(editor),
        'shell_command': SystemCompleter(),
    })
Ejemplo n.º 11
0
    def __init__(self):
        # Compile grammar.
        g = compile(
            r"""
                # First we have an executable.
                (?P<executable>[^\s]+)
                # Ignore literals in between.
                (
                    \s+
                    ("[^"]*" | '[^']*' | [^'"]+ )
                )*
                \s+
                # Secondary grammar
                (
                    /(?P<smodifier>[^\s]+) |
                    (?P<filename>[^\s]+) |
                    -(?P<hmodifier>[^\s]+) |
                    "(?P<double_quoted_filename>[^\s]+)" |
                    '(?P<single_quoted_filename>[^\s]+)'
                )
            """,
            escape_funcs={
                'double_quoted_filename': (lambda string: string.replace('"', '\\"')),
                'single_quoted_filename': (lambda string: string.replace("'", "\\'")),
            },
            unescape_funcs={
                'double_quoted_filename': (lambda string: string.replace('\\"', '"')),  # XXX: not enterily correct.
                'single_quoted_filename': (lambda string: string.replace("\\'", "'")),
            })

        # Create GrammarCompleter
        super(SystemCompleter, self).__init__(
            g,
            {
                'executable': WordCompleter(master_dict.primary, meta_dict=master_dict.primary),
                'hmodifier': WordCompleter(master_dict.secondary_h),
                'smodifier': WordCompleter(master_dict.secondary_s),
                'filename': PathCompleter(only_directories=False, expanduser=True),
                'double_quoted_filename': PathCompleter(only_directories=False, expanduser=True),
                'single_quoted_filename': PathCompleter(only_directories=False, expanduser=True),
            })
Ejemplo n.º 12
0
def test_pathcompleter_completes_directories_with_only_directories():
    # setup: create a test dir with 10 files
    test_dir = tempfile.mkdtemp()
    write_test_files(test_dir)

    # create a sub directory there
    os.mkdir(os.path.join(test_dir, 'subdir'))

    if not test_dir.endswith(os.path.sep):
        test_dir += os.path.sep

    with chdir(test_dir):
        completer = PathCompleter(only_directories=True)
        doc_text = ''
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = [c.text for c in completions]
        assert ['subdir'] == result

    # check that there is no completion when passing a file
    with chdir(test_dir):
        completer = PathCompleter(only_directories=True)
        doc_text = '1'
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        assert [] == completions

    # cleanup
    shutil.rmtree(test_dir)
Ejemplo n.º 13
0
    def test_pathcompleter_completes_files_in_current_directory(self):
        # setup: create a test dir with 10 files
        test_dir = tempfile.mkdtemp()
        write_test_files(test_dir)

        expected = sorted([str(i) for i in range(10)])

        if not test_dir.endswith(os.path.sep):
            test_dir += os.path.sep

        with chdir(test_dir):
            completer = PathCompleter()
            # this should complete on the cwd
            doc_text = ''
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = sorted(c.text for c in completions)
            self.assertEqual(expected, result)

        # cleanup
        shutil.rmtree(test_dir)
Ejemplo n.º 14
0
def test_pathcompleter_completes_files_in_current_directory():
    # setup: create a test dir with 10 files
    test_dir = tempfile.mkdtemp()
    write_test_files(test_dir)

    expected = sorted([str(i) for i in range(10)])

    if not test_dir.endswith(os.path.sep):
        test_dir += os.path.sep

    with chdir(test_dir):
        completer = PathCompleter()
        # this should complete on the cwd
        doc_text = ''
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = sorted(c.text for c in completions)
        assert expected == result

    # cleanup
    shutil.rmtree(test_dir)
Ejemplo n.º 15
0
def test_pathcompleter_completes_files_in_absolute_directory():
    # setup: create a test dir with 10 files
    test_dir = tempfile.mkdtemp()
    write_test_files(test_dir)

    expected = sorted([str(i) for i in range(10)])

    test_dir = os.path.abspath(test_dir)
    if not test_dir.endswith(os.path.sep):
        test_dir += os.path.sep

    completer = PathCompleter()
    # force unicode
    doc_text = text_type(test_dir)
    doc = Document(doc_text, len(doc_text))
    event = CompleteEvent()
    completions = list(completer.get_completions(doc, event))
    result = sorted([c.text for c in completions])
    assert expected == result

    # cleanup
    shutil.rmtree(test_dir)
Ejemplo n.º 16
0
def test_pathcompleter_can_apply_file_filter():
    # setup: create a test dir with 10 files
    test_dir = tempfile.mkdtemp()
    write_test_files(test_dir)

    # add a .csv file
    with open(os.path.join(test_dir, 'my.csv'), 'wb') as out:
        out.write(b'')

    file_filter = lambda f: f and f.endswith('.csv')

    with chdir(test_dir):
        completer = PathCompleter(file_filter=file_filter)
        doc_text = ''
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = [c.text for c in completions]
        assert ['my.csv'] == result

    # cleanup
    shutil.rmtree(test_dir)
Ejemplo n.º 17
0
    def test_pathcompleter_can_apply_file_filter(self):
        # setup: create a test dir with 10 files
        test_dir = tempfile.mkdtemp()
        write_test_files(test_dir)

        # add a .csv file
        with open(os.path.join(test_dir, 'my.csv'), 'wb') as out:
            out.write(b'')

        file_filter = lambda f: f and f.endswith('.csv')

        with chdir(test_dir):
            completer = PathCompleter(file_filter=file_filter)
            doc_text = ''
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = [c.text for c in completions]
            self.assertEqual(['my.csv'], result)

        # cleanup
        shutil.rmtree(test_dir)
Ejemplo n.º 18
0
    def test_pathcompleter_completes_files_in_absolute_directory(self):
        # setup: create a test dir with 10 files
        test_dir = tempfile.mkdtemp()
        write_test_files(test_dir)

        expected = sorted([str(i) for i in range(10)])

        test_dir = os.path.abspath(test_dir)
        if not test_dir.endswith(os.path.sep):
            test_dir += os.path.sep
        
        completer = PathCompleter()
        # force unicode
        doc_text = text_type(test_dir)
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = sorted([c.text for c in completions])
        self.assertEqual(expected, result)

        # cleanup
        shutil.rmtree(test_dir)
Ejemplo n.º 19
0
def test_pathcompleter_get_paths_constrains_path():
    # setup: create a test dir with 10 files
    test_dir = tempfile.mkdtemp()
    write_test_files(test_dir)

    # add a subdir with 10 other files with different names
    subdir = os.path.join(test_dir, 'subdir')
    os.mkdir(subdir)
    write_test_files(subdir, 'abcdefghij')

    get_paths = lambda: ['subdir']

    with chdir(test_dir):
        completer = PathCompleter(get_paths=get_paths)
        doc_text = ''
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = [c.text for c in completions]
        expected = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
        assert expected == result

    # cleanup
    shutil.rmtree(test_dir)
Ejemplo n.º 20
0
    def test_pathcompleter_get_paths_constrains_path(self):
        # setup: create a test dir with 10 files
        test_dir = tempfile.mkdtemp()
        write_test_files(test_dir)

        # add a subdir with 10 other files with different names
        subdir = os.path.join(test_dir, 'subdir')
        os.mkdir(subdir)
        write_test_files(subdir, 'abcdefghij')

        get_paths = lambda: ['subdir']

        with chdir(test_dir):
            completer = PathCompleter(get_paths=get_paths)
            doc_text = ''
            doc = Document(doc_text, len(doc_text))
            event = CompleteEvent()
            completions = list(completer.get_completions(doc, event))
            result = [c.text for c in completions]
            expected = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
            self.assertEqual(expected, result)

        # cleanup
        shutil.rmtree(test_dir)
Ejemplo n.º 21
0
def test_pathcompleter_respects_completions_under_min_input_len():
    # setup: create a test dir with 10 files
    test_dir = tempfile.mkdtemp()
    write_test_files(test_dir)

    # min len:1 and no text
    with chdir(test_dir):
        completer = PathCompleter(min_input_len=1)
        doc_text = ''
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        assert [] == completions

    # min len:1 and text of len 1
    with chdir(test_dir):
        completer = PathCompleter(min_input_len=1)
        doc_text = '1'
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = [c.text for c in completions]
        assert [''] == result

    # min len:0 and text of len 2
    with chdir(test_dir):
        completer = PathCompleter(min_input_len=0)
        doc_text = '1'
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = [c.text for c in completions]
        assert [''] == result

    # create 10 files with a 2 char long name
    for i in range(10):
        with open(os.path.join(test_dir, str(i) * 2), 'wb') as out:
            out.write(b'')

    # min len:1 and text of len 1
    with chdir(test_dir):
        completer = PathCompleter(min_input_len=1)
        doc_text = '2'
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        result = sorted(c.text for c in completions)
        assert ['', '2'] == result

    # min len:2 and text of len 1
    with chdir(test_dir):
        completer = PathCompleter(min_input_len=2)
        doc_text = '2'
        doc = Document(doc_text, len(doc_text))
        event = CompleteEvent()
        completions = list(completer.get_completions(doc, event))
        assert [] == completions

    # cleanup
    shutil.rmtree(test_dir)
Ejemplo n.º 22
0
#! /usr/bin/env python3

from prompt_toolkit import prompt  # NOQA: F401
from prompt_toolkit.validation import ValidationError, Validator
from prompt_toolkit.contrib.completers.filesystem import PathCompleter
from prompt_toolkit.contrib.completers.base import Completer, Completion
from six import string_types

PATH_COMPLETER = PathCompleter(expanduser=True)


def separator_completer(words, sep=' '):
    return SeparatorCompleter(words, sep=sep)


class SeparatorCompleter(Completer):
    """
    Simple autocompletion on a list of accounts. i.e. "Expenses:Unknown"

    :param words: List of words.
    :param sep: The separator to use
    :param ignore_case: If True, case-insensitive completion.
    """
    def __init__(self, words, ignore_case=True, sep=" "):
        self.words = list(words)
        self.ignore_case = ignore_case
        assert all(isinstance(w, string_types) for w in self.words)

    def get_completions(self, document, complete_event):
        # Get word/text before cursor.
        text_before_cursor = document.text_before_cursor