test: simplify completion parsing

Use completion-display-width 0 in inputrc to get completions listed one
per line, return only completed suffix for single completions on the
command line to avoid various weird side effects with escaping etc.

Contains a few known test suite failures that will be addressed later.

Author: scop

test/config/inputrc

@@ -16,6 +16,9 @@ set print-completions-horizontally on
 # Don't use pager when showing completions
 set page-completions off
 
+# Pirnt each completion on its own line
+set completion-display-width 0
+
 # Local variables:
 # mode: shell-script
 # End:

test/t/conftest.py

@@ -393,28 +393,21 @@ class CompletionResult(Iterable[str]):
     Class to hold completion results.
     """
 
-    def __init__(self, output: str, items: Optional[Iterable[str]] = None):
+    def __init__(self, output: Optional[str] = None):
         """
-        When items are specified, they are used as the base for comparisons
-        provided by this class. When not, regular expressions are used instead.
-        This is because it is not always possible to unambiguously split a
-        completion output string into individual items, for example when the
-        items contain whitespace.
-
         :param output: All completion output as-is.
-        :param items: Completions as individual items. Should be specified
-            only in cases where the completions are robustly known to be
-            exactly the specified ones.
         """
-        self.output = output
-        self._items = None if items is None else sorted(items)
+        self.output = output or ""
 
     def endswith(self, suffix: str) -> bool:
         return self.output.endswith(suffix)
 
     def startswith(self, prefix: str) -> bool:
         return self.output.startswith(prefix)
 
+    def _items(self) -> List[str]:
+        return [x.strip() for x in self.output.strip().splitlines()]
+
     def __eq__(self, expected: object) -> bool:
         """
         Returns True if completion contains expected items, and no others.
@@ -428,44 +421,19 @@ def __eq__(self, expected: object) -> bool:
             return False
         else:
             expiter = expected
-        if self._items is not None:
-            return self._items == expiter
-        return bool(
-            re.match(
-                r"^\s*" + r"\s+".join(re.escape(x) for x in expiter) + r"\s*$",
-                self.output,
-            )
-        )
+        return self._items() == expiter
 
     def __contains__(self, item: str) -> bool:
-        if self._items is not None:
-            return item in self._items
-        return bool(
-            re.search(r"(^|\s)%s(\s|$)" % re.escape(item), self.output)
-        )
+        return item in self._items()
 
     def __iter__(self) -> Iterator[str]:
-        """
-        Note that iteration over items may not be accurate when items were not
-        specified to the constructor, if individual items in the output contain
-        whitespace. In those cases, it errs on the side of possibly returning
-        more items than there actually are, and intends to never return fewer.
-        """
-        return iter(
-            self._items
-            if self._items is not None
-            else re.split(r" {2,}|\r\n", self.output.strip())
-        )
+        return iter(self._items())
 
     def __len__(self) -> int:
-        """
-        Uses __iter__, see caveat in it. While possibly inaccurate, this is
-        good enough for truthiness checks.
-        """
-        return len(list(iter(self)))
+        return len(self._items())
 
     def __repr__(self) -> str:
-        return "<CompletionResult %s>" % list(self)
+        return "<CompletionResult %s>" % self._items()
 
 
 def assert_complete(
@@ -527,14 +495,10 @@ def assert_complete(
             result = CompletionResult(output)
         elif got == 2:
             output = bash.match.group(1)
-            result = CompletionResult(
-                output,
-                # Note that this causes returning the sole completion *unescaped*
-                [shlex.split(cmd + output)[-1]],
-            )
+            result = CompletionResult(output)
         else:
             # TODO: warn about EOF/TIMEOUT?
-            result = CompletionResult("", [])
+            result = CompletionResult()
     finally:
         bash.sendintr()
         bash.expect_exact(PS1)
@@ -564,7 +528,7 @@ def assert_complete(
 def completion(request, bash: pexpect.spawn) -> CompletionResult:
     marker = request.node.get_closest_marker("complete")
     if not marker:
-        return CompletionResult("", [])
+        return CompletionResult()
     for pre_cmd in marker.kwargs.get("pre_cmds", []):
         assert_bash_exec(bash, pre_cmd)
     cmd = getattr(request.cls, "cmd", None)
@@ -630,7 +594,7 @@ def assert_complete_at_point(
         bash.expect(fullexpected)
     else:
         # TODO: warn about EOF/TIMEOUT?
-        result = CompletionResult("", [])
+        result = CompletionResult()
 
     return result
 

test/t/test_7z.py

@@ -8,11 +8,11 @@ def test_1(self, completion):
 
     @pytest.mark.complete("7z a ar -tzi")
     def test_2(self, completion):
-        assert completion == "-tzip"
+        assert completion == "p"
 
     @pytest.mark.complete(r"7z x -wa\ ", cwd="_filedir")
     def test_3(self, completion):
-        assert completion == r"-wa b/"
+        assert completion == "b/"
         assert not completion.endswith(" ")
 
     @pytest.mark.complete("7z x ", cwd="7z")

test/t/test_apt_get.py

@@ -9,7 +9,7 @@ def test_1(self, completion):
 
     @pytest.mark.complete("apt-get install ./", cwd="dpkg")
     def test_2(self, completion):
-        assert completion == "./bash-completion-test-subject.deb"
+        assert completion == "bash-completion-test-subject.deb"
 
     @pytest.mark.complete("apt-get build-dep ")
     def test_build_dep_dirs(self, completion):

test/t/test_ccache.py

@@ -12,15 +12,15 @@ def test_2(self, completion):
 
     @pytest.mark.complete("ccache stt")
     def test_3(self, completion):
-        assert "stty" in completion
+        assert completion == "y" or "stty" in completion
 
     @pytest.mark.complete("ccache --zero-stats stt")
     def test_4(self, completion):
-        assert "stty" in completion
+        assert completion == "y" or "stty" in completion
 
     @pytest.mark.complete("ccache --hel", require_cmd=True)
     def test_5(self, completion):
-        assert "--help" in completion
+        assert completion == "p" or "--help" in completion
 
     @pytest.mark.complete("ccache --zero-stats sh +")
     def test_6(self, completion):

test/t/test_cd.py

@@ -9,7 +9,7 @@ def test_1(self, completion):
 
     @pytest.mark.complete("cd fo", env=dict(CDPATH="shared/default"))
     def test_2(self, completion):
-        assert completion == "foo.d/"
+        assert completion == "o.d/"
 
     @pytest.mark.complete("cd fo")
     def test_3(self, completion):

test/t/test_chown.py

@@ -31,39 +31,38 @@ def test_3(self, completion):
     def test_4(self, bash, part_full_user):
         part, full = part_full_user
         completion = assert_complete(bash, "chown %s" % part)
-        assert completion == full
+        assert completion == full[len(part) :]
         assert completion.endswith(" ")
 
     def test_5(self, bash, part_full_user, part_full_group):
         _, user = part_full_user
         partgroup, fullgroup = part_full_group
         completion = assert_complete(bash, "chown %s:%s" % (user, partgroup))
-        assert completion == "%s:%s" % (user, fullgroup)
+        assert completion == fullgroup[len(partgroup) :]
         assert completion.output.endswith(" ")
 
     def test_6(self, bash, part_full_group):
         part, full = part_full_group
         completion = assert_complete(bash, "chown dot.user:%s" % part)
-        assert completion == "dot.user:%s" % full
+        assert completion == full[len(part) :]
         assert completion.output.endswith(" ")
 
     @pytest.mark.parametrize(
         "prefix",
         [
-            # TODO(xfails): check escaping, whitespace
-            pytest.param(r"funky\ user:", marks=pytest.mark.xfail),
+            r"funky\ user:",
             "funky.user:",
-            pytest.param(r"funky\.user:", marks=pytest.mark.xfail),
-            pytest.param(r"fu\ nky.user:", marks=pytest.mark.xfail),
-            pytest.param(r"f\ o\ o\.\bar:", marks=pytest.mark.xfail),
-            pytest.param(r"foo\_b\ a\.r\ :", marks=pytest.mark.xfail),
+            r"funky\.user:",
+            r"fu\ nky.user:",
+            r"f\ o\ o\.\bar:",
+            r"foo\_b\ a\.r\ :",
         ],
     )
     def test_7(self, bash, part_full_group, prefix):
         """Test preserving special chars in $prefix$partgroup<TAB>."""
         part, full = part_full_group
         completion = assert_complete(bash, "chown %s%s" % (prefix, part))
-        assert completion == "%s%s" % (prefix, full)
+        assert completion == full[len(part) :]
         assert completion.output.endswith(" ")
 
     def test_8(self, bash, part_full_user, part_full_group):

test/t/test_cppcheck.py

@@ -20,12 +20,12 @@ def test_4(self, completion):
 
     @pytest.mark.complete("cppcheck --enable=al")
     def test_5(self, completion):
-        assert completion == "--enable=all"
+        assert completion == "l"
 
     @pytest.mark.complete("cppcheck --enable=xx,styl")
     def test_6(self, completion):
-        assert completion == "--enable=xx,style"
+        assert completion == "e"
 
     @pytest.mark.complete("cppcheck --enable=xx,yy,styl")
     def test_7(self, completion):
-        assert completion == "--enable=xx,yy,style"
+        assert completion == "e"

test/t/test_crontab.py

@@ -8,7 +8,7 @@ def test_1(self, completion):
 
     @pytest.mark.complete("crontab -l -")
     def test_only_u_with_l(self, completion):
-        assert completion == "-u"
+        assert completion == "u"
 
     @pytest.mark.complete("crontab -r -")
     def test_no_l_with_r(self, completion):

test/t/test_curl.py

@@ -8,21 +8,21 @@ def test_1(self, completion):
 
     @pytest.mark.complete("curl -o f", cwd="shared/default/foo.d")
     def test_2(self, completion):
-        assert completion == "foo"
+        assert completion == "oo"
 
     @pytest.mark.complete("curl -LRo f", cwd="shared/default/foo.d")
     def test_3(self, completion):
-        assert completion == "foo"
+        assert completion == "oo"
 
     @pytest.mark.complete("curl --o f")
     def test_4(self, completion):
         assert not completion
 
     @pytest.mark.complete("curl --data @", cwd="shared/default/foo.d")
     def test_data_atfile(self, completion):
-        assert completion == "@foo"
+        assert completion == "foo"
 
     @pytest.mark.complete("curl --data @foo.", cwd="shared/default")
     def test_data_atfile_dir(self, completion):
-        assert completion == "@foo.d/"
+        assert completion == "d/"
         assert not completion.endswith(" ")