refactor: rename _realcommand => _comp_realcommand

As a bonus, this implementation eliminates a superfluous `type -P` call.

Author: scop

bash_completion

@@ -1660,23 +1660,25 @@ _fstypes()
 }
 
 # Get real command.
-# - arg: $1  Command
-# - stdout:  Filename of command in PATH with possible symbolic links resolved.
-#            Empty string if command not found.
-# - return:  True (0) if command found, False (> 0) if not.
-_realcommand()
-{
-    type -P "$1" >/dev/null && {
-        if type -p realpath >/dev/null; then
-            realpath "$(type -P "$1")"
-        elif type -p greadlink >/dev/null; then
-            greadlink -f "$(type -P "$1")"
-        elif type -p readlink >/dev/null; then
-            readlink -f "$(type -P "$1")"
-        else
-            type -P "$1"
-        fi
-    }
+# Command is the filename of command in PATH with possible symlinks resolved
+# (if resolve tooling available), empty string if command not found.
+# @param    $1 Command
+# @var[out] ret Resulting string
+# @return   True (0) if command found, False (> 0) if not.
+_comp_realcommand()
+{
+    ret=""
+    local file
+    file=$(type -P "$1") || return $?
+    if type -p realpath >/dev/null; then
+        ret=$(realpath "$file")
+    elif type -p greadlink >/dev/null; then
+        ret=$(greadlink -f "$file")
+    elif type -p readlink >/dev/null; then
+        ret=$(readlink -f "$file")
+    else
+        ret=$file
+    fi
 }
 
 # This function returns the first argument, excluding options
@@ -2513,8 +2515,9 @@ __load_completion()
     fi
 
     # 3) From bin directories extracted from $(realpath "$cmd") and PATH
-    dir=$(_realcommand "$1")
-    paths=("${dir%/*}")
+    local ret
+    _comp_realcommand "$1"
+    paths=("${ret%/*}")
     _comp_split -aF : paths "$PATH"
     for dir in "${paths[@]%/}"; do
         if [[ -d $dir && $dir == ?*/@(bin|sbin) ]]; then

bash_completion.d/000_bash_completion_compat.bash

@@ -165,6 +165,19 @@ _get_pword()
     fi
 }
 
+# Get real command.
+# @deprecated Use `_comp_realcommand` instead.
+# Note that `_comp_realcommand` stores the result in the variable `ret`
+# instead of writing it to stdout.
+_realcommand()
+{
+    local ret
+    _comp_realcommand "$1"
+    local rc=$?
+    printf "%s\n" "$ret"
+    return $rc
+}
+
 # @deprecated Use the variable `_comp_backup_glob` instead.  This is the
 # backward-compatibility name.
 # shellcheck disable=SC2154  # defined in the main "bash_completion"

completions/gcc

@@ -58,31 +58,21 @@ _comp_cmd_gcc()
 } &&
     complete -F _comp_cmd_gcc gcc{,-5,-6,-7,-8} g++{,-5,-6,-7,-8} g77 g95 \
         gccgo{,-5,-6,-7,-8} gcj gfortran{,-5,-6,-7,-8} gpc &&
+    _comp_cmd_gcc__setup_cmd()
     {
-        if cc --version 2>/dev/null | command grep -q GCC ||
-            [[ $(_realcommand cc) == *gcc* ]]; then
-            complete -F _comp_cmd_gcc cc
+        local ret
+        _comp_realcommand "$1"
+        if [[ $ret == *$2* ]] ||
+            "$1" --version 2>/dev/null | command grep -q GCC; then
+            complete -F _comp_cmd_gcc "$1"
         else
-            complete -F _minimal cc
+            complete -F _minimal "$1"
         fi
-        if c++ --version 2>/dev/null | command grep -q GCC ||
-            [[ $(_realcommand c++) == *g++* ]]; then
-            complete -F _comp_cmd_gcc c++
-        else
-            complete -F _minimal c++
-        fi
-        if f77 --version 2>/dev/null | command grep -q GCC ||
-            [[ $(_realcommand f77) == *gfortran* ]]; then
-            complete -F _comp_cmd_gcc f77
-        else
-            complete -F _minimal f77
-        fi
-        if f95 --version 2>/dev/null | command grep -q GCC ||
-            [[ $(_realcommand f95) == *gfortran* ]]; then
-            complete -F _comp_cmd_gcc f95
-        else
-            complete -F _minimal f95
-        fi
-    }
+    } &&
+        _comp_cmd_gcc__setup_cmd cc gcc &&
+        _comp_cmd_gcc__setup_cmd c++ g++ &&
+        _comp_cmd_gcc__setup_cmd f77 gfortran &&
+        _comp_cmd_gcc__setup_cmd f95 gfortran &&
+        unset -f _comp_cmd_gcc__setup_cmd
 
 # ex: filetype=sh

completions/vncviewer

@@ -2,8 +2,9 @@
 
 _vncviewer_bootstrap()
 {
-    local fname
-    case $(_realcommand vncviewer) in
+    local fname ret
+    _comp_realcommand vncviewer
+    case $ret in
         *xvnc4viewer) fname=_xvnc4viewer ;;
         *tightvncviewer) fname=_tightvncviewer ;;
         *) fname=_known_hosts ;;

test/t/unit/test_unit_realcommand.py

@@ -3,27 +3,45 @@
 from conftest import assert_bash_exec, bash_env_saved
 
 
-@pytest.mark.bashcomp(cmd=None, cwd="shared", ignore_env=r"^\+COMPREPLY=")
+@pytest.mark.bashcomp(
+    cmd=None, cwd="shared", ignore_env=r"^\+declare -f __tester$"
+)
 class TestUnitRealCommand:
+    @pytest.fixture
+    def functions(self, bash):
+        assert_bash_exec(
+            bash,
+            (
+                "__tester() { "
+                "local ret rc; "
+                '_comp_realcommand "$1"; '
+                "rc=$?; "
+                'printf %s "$ret"; '
+                "return $rc; "
+                "}"
+            ),
+        )
+
     def test_non_pollution(self, bash):
         """Test environment non-pollution, detected at teardown."""
         assert_bash_exec(
             bash,
-            "foo() { local cur=; _realcommand bar; }; foo; unset -f foo",
+            "foo() { local ret=; _comp_realcommand bar; }; foo; unset -f foo",
             want_output=None,
         )
 
-    def test_basename(self, bash):
+    def test_basename(self, bash, functions):
         with bash_env_saved(bash) as bash_env:
             bash_env.write_variable("PATH", "$PWD/bin:$PATH", quote=False)
             output = assert_bash_exec(
                 bash,
-                "_realcommand arp",
+                "__tester arp",
                 want_output=True,
+                want_newline=False,
             )
             assert output.strip().endswith("/shared/bin/arp")
 
-    def test_basename_nonexistent(self, bash):
+    def test_basename_nonexistent(self, bash, functions):
         filename = "non-existent-file-for-bash-completion-tests"
         skipif = "! type -P %s" % filename
         try:
@@ -32,39 +50,41 @@ def test_basename_nonexistent(self, bash):
             pytest.skipif(skipif)
         output = assert_bash_exec(
             bash,
-            "! _realcommand %s" % filename,
+            "! __tester %s" % filename,
             want_output=False,
         )
         assert output.strip() == ""
 
-    def test_relative(self, bash):
+    def test_relative(self, bash, functions):
         output = assert_bash_exec(
             bash,
-            "_realcommand bin/arp",
+            "__tester bin/arp",
             want_output=True,
+            want_newline=False,
         )
         assert output.strip().endswith("/shared/bin/arp")
 
-    def test_relative_nonexistent(self, bash):
+    def test_relative_nonexistent(self, bash, functions):
         output = assert_bash_exec(
             bash,
-            "! _realcommand bin/non-existent",
+            "! __tester bin/non-existent",
             want_output=False,
         )
         assert output.strip() == ""
 
-    def test_absolute(self, bash):
+    def test_absolute(self, bash, functions):
         output = assert_bash_exec(
             bash,
-            '_realcommand "$PWD/bin/arp"',
+            '__tester "$PWD/bin/arp"',
             want_output=True,
+            want_newline=False,
         )
         assert output.strip().endswith("/shared/bin/arp")
 
-    def test_absolute_nonexistent(self, bash):
+    def test_absolute_nonexistent(self, bash, functions):
         output = assert_bash_exec(
             bash,
-            '! _realcommand "$PWD/bin/non-existent"',
+            '! __tester "$PWD/bin/non-existent"',
             want_output=False,
         )
         assert output.strip() == ""