Improve autocompletion function on file name completion.

Author: kianasun

news/4842.feature

@@ -0,0 +1,2 @@
+Improve autocompletion function on file name completion after options
+which have ``<file>``, ``<dir>`` or ``<path>`` as metavar.

src/pip/_internal/__init__.py

@@ -114,6 +114,14 @@ def autocomplete():
         options = [(x, v) for (x, v) in options if x not in prev_opts]
         # filter options by current input
         options = [(k, v) for k, v in options if k.startswith(current)]
+        # get completion type given cwords and available subcommand options
+        completion_type = get_path_completion_type(
+            cwords, cword, subcommand.parser.option_list_all)
+        # get completion files and directories if ``completion_type`` is
+        # ``<file>``, ``<dir>`` or ``<path>``
+        if completion_type:
+            options = auto_complete_paths(current, completion_type)
+            options = ((opt, 0) for opt in options)
         for option in options:
             opt_label = option[0]
             # append '=' to options which require args
@@ -122,18 +130,71 @@ def autocomplete():
             print(opt_label)
     else:
         # show main parser options only when necessary
-        if current.startswith('-') or current.startswith('--'):
-            opts = [i.option_list for i in parser.option_groups]
-            opts.append(parser.option_list)
-            opts = (o for it in opts for o in it)
-
+        opts = [i.option_list for i in parser.option_groups]
+        opts.append(parser.option_list)
+        opts = (o for it in opts for o in it)
+        if current.startswith('-'):
             subcommands += [i.get_opt_string() for i in opts
                             if i.help != optparse.SUPPRESS_HELP]
+        else:
+            # get completion type given cwords and all available options
+            completion_type = get_path_completion_type(cwords, cword, opts)
+            if completion_type:
+                subcommands = auto_complete_paths(current, completion_type)
 
         print(' '.join([x for x in subcommands if x.startswith(current)]))
     sys.exit(1)
 
 
+def get_path_completion_type(cwords, cword, opts):
+    """Get the type of path completion(``file``, ``dir``, ``path`` or None)
+
+    :param cwords: same as the environmental variable ``COMP_WORDS``
+    :param cword: same as the environmental variable ``COMP_CWORD``
+    :param opts: The available options to check
+    :return: path completion type(``file``, ``dir``, ``path`` or None)
+    """
+    if cword >= 2 and cwords[cword - 2].startswith('-'):
+        for opt in opts:
+            if opt.help == optparse.SUPPRESS_HELP:
+                continue
+            for o in str(opt).split('/'):
+                if cwords[cword - 2].split('=')[0] == o:
+                    if any(x in ('path', 'file', 'dir')
+                            for x in opt.metavar.split('/')):
+                        return opt.metavar
+
+
+def auto_complete_paths(current, completion_type):
+    """If ``completion_type`` is ``file`` or ``path``, list all regular files
+    and directories starting with ``current``; otherwise only list directories
+    starting with ``current``.
+
+    :param current: The word to be completed
+    :param completion_type: path completion type(`file`, `path` or `dir`)i
+    :return: A generator of regular files and/or directories
+    """
+    # split ``current`` into two parts(directory and name)
+    directory, filename = os.path.split(current)
+    # change directory to ``directory``
+    current_path = os.path.abspath(directory)
+    # check whether ``current_path`` is accessible
+    if os.access(current_path, os.R_OK):
+        # list all files that start with ``filename``
+        file_list = (x for x in os.listdir(current_path)
+                     if x.startswith(filename))
+        for f in file_list:
+            opt = os.path.join(current_path, f)
+            comp_file = os.path.join(directory, f)
+            # complete regular files when there is not ``<dir>`` after option
+            # complete directories when there is ``<file>``, ``<path>`` or
+            # ``<dir>``after option
+            if completion_type != 'dir' and os.path.isfile(opt):
+                yield comp_file
+            elif os.path.isdir(opt):
+                yield os.path.join(comp_file, '')
+
+
 def create_main_parser():
     parser_kw = {
         'usage': '\n%prog <command> [options]',

tests/data/completepaths/README.txt

@@ -77,7 +77,7 @@ def test_completion_alone(script):
            'completion alone failed -- ' + result.stderr
 
 
-def setup_completion(script, words, cword):
+def setup_completion(script, words, cword, cwd=None):
     script.environ = os.environ.copy()
     script.environ['PIP_AUTO_COMPLETE'] = '1'
     script.environ['COMP_WORDS'] = words
@@ -87,6 +87,7 @@ def setup_completion(script, words, cword):
     result = script.run(
         'python', '-c', 'import pip._internal;pip._internal.autocomplete()',
         expect_error=True,
+        cwd=cwd,
     )
 
     return result, script
@@ -113,14 +114,97 @@ def test_completion_for_default_parameters(script):
 
 def test_completion_option_for_command(script):
     """
-    Test getting completion for ``--`` in command (eg. pip search --)
+    Test getting completion for ``--`` in command (e.g. ``pip search --``)
     """
 
     res, env = setup_completion(script, 'pip search --', '2')
     assert '--help' in res.stdout,\
            "autocomplete function could not complete ``--``"
 
 
+def test_completion_files_after_option(script, data):
+    """
+    Test getting completion for <file> or <dir> after options in command
+    (e.g. ``pip install -r``)
+    """
+    res, env = setup_completion(
+        script, ('pip install -r r'),
+        '3',
+        data.complete_paths
+    )
+    assert 'requirements.txt' in res.stdout,\
+        "autocomplete function could not complete <file>"\
+        "after options in command"
+    assert 'README.txt' not in res.stdout,\
+        "autocomplete function completed <file> that"\
+        "should not be completed"
+    assert 'resources' in res.stdout,\
+        "autocomplete function could not complete <dir>"\
+        "after options in command"
+
+
+def test_completion_not_files_after_option(script, data):
+    """
+    Test not getting completion files after options which not applicable
+    (e.g. ``pip install``)
+    """
+    res, env = setup_completion(
+        script, ('pip install r'),
+        '2',
+        data.complete_paths
+    )
+    assert 'requirements.txt' not in res.stdout,\
+        "autocomplete function completed <file> when"\
+        "it should not complete"
+
+
+def test_completion_directories_after_option(script, data):
+    """
+    Test getting completion <dir> after options in command
+    (e.g. ``pip --cache-dir``)
+    """
+    res, env = setup_completion(
+        script,
+        ('pip --cache-dir resources'),
+        '2',
+        data.complete_paths
+    )
+    assert os.path.join('resources', '') in res.stdout,\
+        "autocomplete function could not complete <dir> after options"
+
+
+def test_completion_subdirectories_after_option(script, data):
+    """
+    Test getting completion <dir> after options in command
+    given path of a directory
+    """
+    res, env = setup_completion(
+        script,
+        ('pip --cache-dir ' + os.path.join('resources', '')),
+        '2',
+        data.complete_paths
+    )
+    assert os.path.join('resources',
+                        os.path.join('images', '')) in res.stdout,\
+        "autocomplete function could not complete <dir>"\
+        "given path of a directory after options"
+
+
+def test_completion_path_after_option(script, data):
+    """
+    Test getting completion <path> after options in command
+    given absolute path
+    """
+    res, env = setup_completion(
+        script,
+        ('pip install -e ' + os.path.join(data.complete_paths, 'R')),
+        '3'
+    )
+    assert os.path.join(data.complete_paths, 'README.txt') in res.stdout,\
+        "autocomplete function could not complete <path>"\
+        "after options in command given absolute path"
+
+
 @pytest.mark.parametrize('flag', ['--bash', '--zsh', '--fish'])
 def test_completion_uses_same_executable_name(script, flag):
     expect_stderr = sys.version_info[:2] == (3, 3)

tests/data/completepaths/requirements.txt

@@ -112,6 +112,10 @@ def indexes(self):
     def reqfiles(self):
         return self.root.join("reqfiles")
 
+    @property
+    def complete_paths(self):
+        return self.root.join("completepaths")
+
     @property
     def find_links(self):
         return path_to_url(self.packages)