fix(_comp_command_offset): Add support for complete -C

Author: elyscape

bash_completion

@@ -2307,33 +2307,83 @@ _comp_command_offset()
                     #     *something* for every command thrown at it ($cspec != empty)
                     _minimal
                 fi
-            elif [[ $cspec == *' -F '* ]]; then
-                # complete -F <function>
+            elif [[ $cspec == *\ -[CF]\ * ]]; then
+                if [[ $cspec == *' -F '* ]]; then
+                    # complete -F <function>
 
-                # get function name
-                local func=${cspec#* -F }
-                func=${func%% *}
+                    # get function name
+                    local func=${cspec#* -F }
+                    func=${func%% *}
 
-                if ((${#COMP_WORDS[@]} >= 2)); then
-                    $func "$cmd" "${COMP_WORDS[-1]}" "${COMP_WORDS[-2]}"
+                    if ((${#COMP_WORDS[@]} >= 2)); then
+                        $func "$cmd" "${COMP_WORDS[-1]}" "${COMP_WORDS[-2]}"
+                    else
+                        $func "$cmd" "${COMP_WORDS[-1]}"
+                    fi
+
+                    # restart completion (once) if function exited with 124
+                    if (($? == 124 && retry_count++ == 0)); then
+                        # Note: When the completion function returns 124, the
+                        # state of COMPREPLY is discarded.
+                        COMPREPLY=()
+
+                        cspec=$(complete -p "$compcmd" 2>/dev/null)
+
+                        # Note: When completion spec is removed after 124, we
+                        # do not generate any completions including the default
+                        # ones. This is the behavior of the original Bash
+                        # progcomp.
+                        [[ $cspec ]] || break
+
+                        continue
+                    fi
                 else
-                    $func "$cmd" "${COMP_WORDS[-1]}"
-                fi
+                    # complete -C <command>
 
-                # restart completion (once) if function exited with 124
-                if (($? == 124 && retry_count++ == 0)); then
-                    # Note: When the completion function returns 124, the state
-                    # of COMPREPLY is discarded.
-                    COMPREPLY=()
+                    # get command name
+                    local completer=${cspec#* -C \'}
 
-                    cspec=$(complete -p "$compcmd" 2>/dev/null)
+                    # completer commands are always single-quoted
+                    if ! _comp_dequote "'$completer"; then
+                        _minimal
+                        break
+                    fi
+                    completer=${ret[0]}
+
+                    local -a suggestions
+
+                    local reset_monitor=$(shopt -po monitor) reset_lastpipe=$(shopt -p lastpipe)
+                    set +o monitor
+                    shopt -s lastpipe
+
+                    (
+                        export COMP_KEY COMP_LINE COMP_POINT COMP_TYPE
 
-                    # Note: When completion spec is removed after 124, we do
-                    # not generate any completions including the default ones.
-                    # This is the behavior of the original Bash progcomp.
-                    [[ $cspec ]] || break
+                        if ((${#COMP_WORDS[@]} >= 2)); then
+                            $completer "$cmd" "${COMP_WORDS[-1]}" \
+                                "${COMP_WORDS[-2]}"
+                        else
+                            $completer "$cmd" "${COMP_WORDS[-1]}"
+                        fi
+                    ) | mapfile suggestions
 
-                    continue
+                    $reset_monitor
+                    $reset_lastpipe
+
+                    local suggestion
+                    local i=0
+                    COMPREPLY=()
+                    for suggestion in "${suggestions[@]}"; do
+                        # `mapfile -t` was added in bash 4.4, so we have to
+                        # strip trailing newlines manually
+                        suggestion="${suggestion%$'\n'}"
+
+                        COMPREPLY[i]+=${COMPREPLY[i]+$'\n'}$suggestion
+
+                        if [[ $suggestion != *\\ ]]; then
+                            ((i++))
+                        fi
+                    done
                 fi
 
                 # restore initial compopts

test/fixtures/_command_offset/completer

@@ -0,0 +1,30 @@
+#!/bin/sh
+
+case "${2-}" in
+    b|ba|bar)
+        echo bar
+        ;;
+    cont1*)
+        echo cont10
+        echo cont11\\
+        ;;
+    f|fo|foo)
+        echo foo
+        ;;
+    l)
+        echo line\\
+        echo two
+        echo long
+        ;;
+    li*)
+        echo line\\
+        echo two
+        ;;
+    lo*)
+        echo long
+        ;;
+    *)
+        echo bar
+        echo foo
+        ;;
+esac

test/t/unit/test_unit_command_offset.py

@@ -12,7 +12,8 @@ def join(words):
 
 @pytest.mark.bashcomp(
     cmd=None,
-    ignore_env=r"^[+-]COMPREPLY=",
+    cwd="_command_offset",
+    ignore_env=r"^[+-](COMPREPLY|ret)=",
 )
 class TestUnitCommandOffset:
     wordlist = sorted(["foo", "bar"])
@@ -40,6 +41,8 @@ def functions(self, bash):
                 % {"idx": idx, "comp": comp},
             )
 
+        assert_bash_exec(bash, "complete -C ./completer cmd6")
+
     def test_1(self, bash, functions):
         assert_complete(bash, 'cmd1 "/tmp/aaa bbb" ')
         assert_bash_exec(bash, "! complete -p aaa", want_output=None)
@@ -72,3 +75,18 @@ def test_2(self, bash, functions, cmd, expected_completion):
         cleared before the retry.
         """
         assert assert_complete(bash, "meta %s " % cmd) == expected_completion
+
+    @pytest.mark.parametrize(
+        "cmd,expected_completion",
+        [
+            ("cmd6 ", wordlist),
+            ("cmd6 l", ["line\\^Jtwo", "long"]),
+            ("cmd6 lo", ["ng"]),
+            ("cmd6 line", ["\\^Jtwo"]),
+            ("cmd6 cont1", ["cont10", "cont11\\"]),
+        ],
+    )
+    def test_3(self, bash, functions, cmd, expected_completion):
+        got = assert_complete(bash, f"cmd1 {cmd}")
+        assert got == assert_complete(bash, cmd)
+        assert got == expected_completion