roszsh

# roszsh - functions to support ROS users
# Useful things to know:
# 'local' variables get unset after function, all others stay forever
# 'reply' is the var used by zsh compctl builtin

function _rossed {
    if [[ `uname` == Darwin || `uname` == FreeBSD ]]; then
        sed -E "$@"
    else
        sed -r "$@"
    fi
}

function _rosfind {
    if [[ `uname` == Darwin || `uname` == FreeBSD ]]; then
        # BSD find needs -E for extended regexp
        find -E "$@"
    else
        find "$@"
    fi
}

# _ros_location_find
# based on $ROS_LOCATIONS, which the user can set to any colon
# separated of key=folder pairs also resolves keys 'log' and
# 'test_results' to ROS defaults finally resolves to package, then
# stack echoes its result
function _ros_location_find {
    local ROS_LOCATION_KEYS_ARR ROS_LOCATIONS_ARR loc
    ROS_LOCATION_KEYS_ARR=(`echo $ROS_LOCATIONS | _rossed -e 's/([^:=]*)=([^:=]*)(:*[^=])*(:|$)/\1 /g'`)
    ROS_LOCATIONS_ARR=(`echo $ROS_LOCATIONS | _rossed -e 's/([^:=]*)=([^:=]*)(:*[^=])*(:|$)/\2 /g' -e "s|~|$HOME|g"`)

    for (( i = 1 ; i <= ${#ROS_LOCATION_KEYS_ARR[@]} ; i++ )); do
        if [[ $1 == ${ROS_LOCATION_KEYS_ARR[$i]} ]]; then
            echo ${ROS_LOCATIONS_ARR[i]}
            return 0
        fi
    done

    if [[ $1 == log ]]; then
        echo `roslaunch-logs`
        return 0
    elif [[ $1 == test_results ]]; then
        echo `rosrun rosunit test_results_dir.py`
        return 0
    fi

    loc=`export ROS_CACHE_TIMEOUT=-1.0 && rospack find $1 2> /dev/null`
    if [[ $? != 0 ]]; then
        loc=`export ROS_CACHE_TIMEOUT=-1.0 && rosstack find $1 2> /dev/null`
        if [[ $? != 0 ]]; then
            return 1
        fi
        echo $loc
        return 0
    fi
    echo $loc
    return 0
}

function _ros_list_locations {
    local ROS_LOCATION_KEYS packages stacks
    ROS_LOCATION_KEYS=`echo $ROS_LOCATIONS | _rossed -e 's/([^:=]*)=([^:=]*)(:*[^=])*(:|$)/\1 /g'`
    packages=`export ROS_CACHE_TIMEOUT=-1.0 && rospack list-names`
    stacks=`export ROS_CACHE_TIMEOUT=-1.0 && rosstack list-names`
    echo $packages $stacks log test_results $ROS_LOCATION_KEYS | tr ' ' '\n'
    return 0
}

function _ros_decode_path {
    local rosname rosdir reldir last rospackdir rosstack_result rosstackdir
    rosvals=()
    if [[ -z $1 ]]; then
        return 0
    fi

    echo $1 | grep -G '.\+/.*' > /dev/null
    if [[ $? == 0 ]]; then
        rosname=${1%%/*}
        reldir=/${1#*/}
        last=${reldir##*/}
        reldir=${reldir%/*}/
    else
        rosname=$1
        if [[ -z $2 || $2 != "forceeval" ]]; then
            rosvals=(${rosname})
            return 1
        fi
    fi

    if [[ $rosname == ros ]]; then
        rosdir=`rosstack find ros`
    elif [[ $rosname == pkg ]]; then
        rosdir=${ROS_PACKAGE_PATH%%:*}
    elif [[ $rosname == log ]]; then
        rosdir=`roslaunch-logs`
    elif [[ $rosname == test_results ]]; then
        rosdir=`rosrun rosunit test_results_dir.py`
    else
        rospackdir=`export ROS_CACHE_TIMEOUT=-1.0 && rospack find $rosname 2> /dev/null`
        rospack_result=$?
        rosstackdir=`export ROS_CACHE_TIMEOUT=-1.0 && rosstack find $rosname 2> /dev/null`
        rosstack_result=$?
        if [[ $rospack_result == 0 ]]; then
            rosdir=$rospackdir
        elif [[ $rosstack_result == 0 ]]; then
            rosdir=$rosstackdir
        else
            rosvals=(${rosname})
            return 1
        fi
    fi

    rosvals=(${rosname} ${rosdir} ${reldir} ${last})
}

function rospython {
    if [[ $1 = "--help" ]]; then
        echo -e "usage: rospython [package] \n\nRun python loading package manifest first."
        return 0
    fi
    if [[ -z $1 ]]; then
        if [[ -f ./manifest.xml ]]; then
            pkgname=`basename \`pwd\``
            python -i -c "import roslib; roslib.load_manifest('$pkgname')"
        else
            python
        fi
    else
        python -i -c "import roslib; roslib.load_manifest('$1')"
    fi
}

function roscd {
    local rosvals
    if [[ $1 = "--help" ]] | [[ $# -gt 1 ]]; then
        echo -e "usage: roscd package\n\nJump to target package."
        return 0
    fi
    if [ -z $1 ]; then
        if [ ! -z $ROS_WORKSPACE ]; then
            cd ${ROS_WORKSPACE}
            return 0
        fi
        if [ ! -z $CMAKE_PREFIX_PATH ]; then
            workspaces=("${(s/:/)CMAKE_PREFIX_PATH}")
            for ws in "${workspaces[@]}"; do
                if [ -f $ws/.catkin ]; then
                    cd ${ws}
                    return 0
                fi
            done
        fi
        echo -e "Neither ROS_WORKSPACE is set nor a catkin workspace is listed in CMAKE_PREFIX_PATH.  Please set ROS_WORKSPACE or source a catkin workspace to use roscd with no arguments."
        return 1
    fi

    _ros_decode_path $1 forceeval
    if [ $? != 0 ]; then
        echo "roscd: No such package '$1'"
        return 1
    elif [ -z ${rosvals[1]} ]; then
        if [ -z $ROS_WORKSPACE ]; then
            echo -e "No ROS_WORKSPACE set.  Please set ROS_WORKSPACE to use roscd with no arguments."
            return 1
        fi
        cd ${ROS_WORKSPACE}
        return 0
    else
        cd ${rosvals[2]}${rosvals[3]}${rosvals[4]}
        return 0
    fi
}

function _is_integer {
    [ "$1" -eq "$1" ] > /dev/null 2>&1
    return $?
}

function rosd {
    if [[ $1 = "--help" ]]; then
        echo -e "usage: rosd\n\nDisplays the list of currently remembered directories with indexes."
        return 0
    fi
    let count=0;
    for items in `dirs`;
    do
        echo $count $items;
        let count=$((count+1));
    done
}

function rospd {
    if [[ $1 = "--help" ]]; then
        echo -e "usage: rospd\n\nLike pushd, also accepts indexes from rosd."
        return 0
    fi
    if _is_integer $1; then
        pushd +$1 > /dev/null ;
    else
        local rosvals
        _ros_decode_path $1 forceeval
        pushd ${rosvals[2]}${rosvals[3]}${rosvals[4]} > /dev/null ;
    fi
    rosd
}

function rosls {
    local rosvals
    if [[ $1 = "--help" ]]; then
        echo -e "usage: rosls [package]\n\nLists contents of a package directory."
        return 0
    fi
    _ros_decode_path $1 forceeval
    ls ${rosvals[2]}${rosvals[3]}${rosvals[4]} $2
}

# sets arg as return value
function _roscmd {
    local pkgdir exepath opt
    pkgdir=`export ROS_CACHE_TIMEOUT=-1.0 && rospack find $1 2> /dev/null`
    if [[ $? != 0 ]] ; then
        echo "Couldn't find package [$1]"
        return 1
    fi
    exepath=(`find $pkgdir -name $2 -type f`)
    if [[ ${#exepath[@]} == 0 ]] ; then
        echo "That file does not exist in that package."
        return 1
    elif [[ ${#exepath[@]} -gt 1 ]] ; then
        echo "You have chosen a non-unique filename, please pick one of the following:"
        select opt in ${exepath[@]}; do
            echo $opt
            break
        done
    else
        opt=${exepath[1]}
    fi
    arg=${opt}
}

function rosed {
    local arg
    if [[ $1 = "--help" ]]; then
        echo -e "usage: rosed [package] [file]\n\nEdit a file within a package."
        return 0
    fi
    _roscmd ${1} ${2}
    if [[ -z $EDITOR ]]; then
        vim ${arg}
    else
        $EDITOR ${arg}
    fi
}

function roscp {
    local arg
    if [[ $1 = "--help" ]] | [[ $# -ne 3 ]]; then
        echo -e "usage: roscp package filename target\n\nCopy a file from a package to target location."
        return 0
    fi
    _roscmd ${1} ${2}
    cp ${arg} ${3}
}

function _roscomplete {
    local arg opts stack_opts
    reply=()
    opts=`export ROS_CACHE_TIMEOUT=-1.0 && rospack list-names`
    stack_opts=`export ROS_CACHE_TIMEOUT=-1.0 && rosstack list-names`
    IFS=$'\n'
    reply=(${=opts} ${=stack_opts})
    unset IFS
}

function _roscomplete_rosmake {
    local param
    _roscomplete
    if [[ $PREFIX == "--"* ]]; then
        param="--test-only --all --mark-installed --unmark-installed --robust --build-everything --specified-only --buildtest --buildtest1 --output --pre-clean --bootstrap --disable-logging --target --pjobs --threads --profile --skip-blacklist  --status-rate"
        reply=(${=reply} ${=param})
    fi
}

function _roscomplete_sub_dir {
    local arg opts rosvals sedcmd stack_opts
    reply=()
    arg="$1"
    _ros_decode_path ${arg}
    if [[ -z ${rosvals[3]} ]]; then
        opts=`export ROS_CACHE_TIMEOUT=-1.0 && rospack list-names`
        stack_opts=`export ROS_CACHE_TIMEOUT=-1.0 && rosstack list-names`
        IFS=$'\n'
        reply=(${=opts} ${=stack_opts})
        unset IFS
    else
        if [ -e ${rosvals[2]}${rosvals[3]} ]; then
            sedcmd="s:^${rosvals[2]}:${rosvals[1]}:"g
            opts=`find ${rosvals[2]}${rosvals[3]} -maxdepth 1 -mindepth 1 -type d ! -regex ".*/[.].*" -print0 | tr '\000' '\n' | sed -e "$sedcmd"`
        else
            opts=''
        fi
        IFS=$'\n'
        reply=(${=opts})
        unset IFS
    fi
}

function _roscomplete_search_dir {
    local words arg opts pkg pkgdir pkgdir_result stack_result catkin_package_libexec_dir
    reply=()
    words=(${=BUFFER})
    if [[ $BUFFER[-1] == ' ' ]]
    then
        pkg=${words[-1]}
    else
        pkg=${words[-2]}
    fi
    pkgdir=`export ROS_CACHE_TIMEOUT=-1.0 && rospack find ${pkg} 2> /dev/null`
    pkgdir_result=$?
    catkin_package_libexec_dir=`catkin_find --without-underlays --libexec ${pkg} 2> /dev/null`
    if [[ $? != 0 ]]
    then
        catkin_package_libexec_dir=""
    fi
    stackdir=`export ROS_CACHE_TIMEOUT=-1.0 && rosstack find ${pkg} 2> /dev/null`
    stack_result=$?
    if [[ $pkgdir_result == 0 ]]; then
        opts=`find $pkgdir $catkin_package_libexec_dir ${=1} -print0 | tr '\000' '\n' | sed -e "s/.*\/\(.*\)/\1/g"`
    elif [[ $stack_result == 0 ]] ; then
        opts=`find $stackdir ${=1} -print0 | tr '\000' '\n' | sed -e "s/.*\/\(.*\)/\1/g"`
    else
        opts=""
    fi
    IFS=$'\n'
    reply=(${=opts})
    unset IFS
}

function _roscomplete_exe {
    local perm
    if [[ `uname` == Darwin ]]; then
        perm="+111"
    else
        perm="/111"
    fi
    _roscomplete_search_dir "-type f -perm $perm -regex .*/.*$"
}

function _roscomplete_file {
    _roscomplete_search_dir "-type f ! -regex .*/[.].* ! -regex .*[.][oa]$"
}

function _roscomplete_launchfile {
    _roscomplete_search_dir "( -type f -regex .*\.launch$ -o -type f -regex .*\.test$ )"
}

function _roscomplete_rosbag {
    local opts
    reply=()

    if [[ ${CURRENT} == 2 ]]; then
        opts="check compress decompress filter fix help info play record reindex"
        reply=(${=opts})
    else
        if [[ ${=${(s: :)words}[$(( ${CURRENT} ))]} =~ \-\- ]]; then
            opts="--all --help"
            case ${=${(s: :)words}[2]} in
                check)
                    opts="--genrules --append --noplugins --help"
                    ;;
                compress|decompress)
                    opts="--output-dir --force --quiet --help"
                    ;;
                filter)
                    opts="--print --help"
                    ;;
                fix)
                    opts="--force --noplugins --help"
                    ;;
                info)
                    opts="--yaml --key --freq --help"
                    ;;
                play)
                    opts="--help --quiet --immediate --pause --queue --clock --hz --delay --rate --start --skip-empty --loop --keep-alive --try-future-version --topics --bags"
                    ;;
                record)
                    opts="--help --all --regex --exclude --quiet --output-prefix --output-name --split --size --duration --buffsize --limit --node --bz2"
                    ;;
                reindex)
                    opts="--help --force --quiet --output-dir"
                    ;;
            esac
            reply=(${=opts})
        else
            case ${=${(s: :)words}[2]} in
                record)
                    opts=$(rostopic list 2>/dev/null)
                    if [ -z "$opts" ]; then
                        reply="" #Prevent execution of next rule
                        return
                    fi
                    reply=(${=opts})
                    ;;
            esac
        fi
    fi

}

function _roscomplete_rospack {
    local opts
    reply=()
    if [[ ${CURRENT} == 2 ]]; then
        opts="help find list list-names list-duplicates langs depends depends-manifests depends1 depends-indent depends-msgsrv depends-why rosdep rosdep0 vcs vcs0 depends-on depends-on1 export plugins cflags-only-I cflags-only-other libs-only-L libs-only-l libs-only-other profile"
        reply=(${=opts})
    else
        opts=`rospack list-names`
        reply=(${=opts})
    fi
}

function _roscomplete_rosnode {
    local opts
    reply=()

    if [[ ${CURRENT} == 2 ]]; then
        opts="ping list info machine kill cleanup"
        reply=(${=opts})
    elif [[ ${CURRENT} == 3 ]]; then
        case ${=${(s: :)words}[2]} in
            info)
                opts=`rosnode list 2> /dev/null`
                reply=(${=opts})
                ;;
            ping|list|kill)
                if [[ ${=${(s: :)words}[$(( ${CURRENT} ))]} =~ \-\- ]]; then
                    opts="--all --help"
                else
                    opts=`rosnode list 2> /dev/null`
                fi
                reply=(${=opts})
                ;;
            machine)
                # This takes more logic to determine which machines are present.
                ;;
        esac
    else
        case ${=${(s: :)words}[2]} in
            kill)
                # complete on node name
                opts=`rosnode list 2> /dev/null`
                reply=(${=opts})
                ;;
        esac
    fi
}

function _roscomplete_rosparam {
    local opts
    reply=()

    if [[ ${CURRENT} == 2 ]]; then
        opts="set get load dump delete list"
        reply=(${=opts})
    elif [[ ${CURRENT} == 3 ]]; then
        case ${=${(s: :)words}[2]} in
            set|get|delete|list)
                opts=`rosparam list 2> /dev/null`
                reply=(${=opts})
                ;;
            load|dump)
                # complete on files
                reply=(${=opts})
                ;;
        esac
    elif [[ ${CURRENT} == 4 ]]; then
        case ${=${(s: :)words}[2]} in
            load|dump)
                # complete on namespace
                opts=`rosparam list 2> /dev/null`
                reply=(${=opts})
                ;;
        esac
    fi

}
function _roscomplete_rostopic {
    local opts word
    reply=()

    if [[ ${CURRENT} == 2 ]]; then
        opts="bw echo hz list pub type find info"
        reply=(${=opts})
    elif [[ ${CURRENT} > 2 ]]; then
        if [[ ${=${(s: :)words}[$(( ${CURRENT} ))]} =~ \-\- ]]; then
            case ${=${(s: :)words}[2]} in
                pub)
                    opts="--help --rate --once --file --latch"
                    ;;
                bw)
                    opts="--help --window"
                    ;;
                echo)
                    opts="--help --bag --filter --nostr --noarr --clear --all --offset"
                    ;;
                hz)
                    opts="--help --window --filter"
                    ;;
                list)
                    opts="--help --bag --verbose --host"
                    ;;
                type|info)
                    opts="--help"
                    ;;
            esac
            reply=(${=opts})
        else
            case ${=${(s: :)words}[2]} in
                bw|echo|hz|list|type|info)
                    if [[ ${=${(s: :)words}[$(( ${CURRENT} -1 ))]} == "-b" ]]; then
                        opts=`find . -maxdepth 1 -type f -not -name ".*" -not -name "*[~#]" | sed 's!.*/!!'`
                        reply=(${=opts})
                    else
                        opts=`rostopic list 2> /dev/null`
                        reply=(${=opts})
                    fi
                    ;;
                find)
                    opts=`_msg_opts ${=${(s: :)words[-1]}}`
                    reply=(${=opts})
                    ;;
                pub)
                    if [[ ${CURRENT} == 3 ]]; then
                        opts=`rostopic list 2> /dev/null`
                        reply=(${=opts})
                    elif [[ ${CURRENT} == 4 ]]; then
                        if [[ ${=${(s: :)words}[$(( ${CURRENT} ))]} =~ / ]]; then
                            word=(${=words})
                            type=`rostopic info ${word[3]} 2> /dev/null`
                            opts=${=${type[(w)2]}}
                        else
                            word=(${=words})
                            type=`rostopic info ${word[3]} 2> /dev/null`
                            opts=${=${type[(w)2]}}
                        fi
                        reply=(${=opts})
                    elif [[ ${CURRENT} == 5 ]]; then
                        w=(${=words})
                        opts=`rosmsg-proto msg 2> /dev/null -s ${=${w[-1]}}`
                        reply=(${opts})
                    fi
                    ;;
            esac
        fi
    fi
}

function _roscomplete_rosservice {
    local opts
    reply=()


    if [[ ${CURRENT} == 2 ]]; then
        opts="list call type find uri"
        reply=(${=opts})
    elif [[ ${CURRENT} == 3 ]]; then
        case ${=${(s: :)words}[2]} in
            uri|list|type|call)
                opts=`rosservice list 2> /dev/null`
                IFS=$'\n'
                reply=(${=opts})
                unset IFS
                ;;
            find)
                opts=`_srv_opts ${=${(s: :)words[-1]}}`
                reply=(${=opts})
                ;;
        esac
    elif [[ ${CURRENT} == 4 ]]; then
        case ${=${(s: :)words}[2]} in
            call)
                type=`rosservice type ${=${(s: :)words[-1]}}`
                opts=`rosmsg-proto srv 2> /dev/null -s ${type}`
                reply=(${=opts})
                ;;
        esac
    fi

}

function _msg_opts {
    local pkgname msgname searchmsg pkgs count pkgname2 opts result
    unset searchmsg

    if [[ $1 =~ .+/.* ]]; then
        pkgname=${1%%/*}
        msgname=${1#*/}
        searchmsg=1
    else
        pkgname=${1}
    fi

    if [[ -z ${searchmsg} ]]; then
        pkgs=`command rospack list | grep "^${pkgname}"`
        count=0

        opts=""

        for pkg in ${(f)pkgs}; do
            pkgdir=${=${(s: :)pkg}[2]}
            if [[ -d $pkgdir/msg ]]; then
                pkgname2=${=${(s: :)pkg}[1]}
                opts="$opts $pkgname2/"
                count=$((count+1))
            fi
        done

        if [[ $count > 0 ]]; then
            echo $opts
            return 0
        fi
    fi

    pkgpath=`rospack find ${pkgname} 2> /dev/null`
    if [[ $?  == 0 ]] && [[ -d ${pkgpath}/msg ]]; then
        result=`find -L ${pkgpath}/msg -maxdepth 1 -mindepth 1 -name \*.msg ! -regex ".\*/[.].\*" -print0 | tr '\000' '\n' | sed -e "s/.*\/\(.*\)\.msg/${pkgname}\/\1/g"`
        echo $result
    fi
}

function _roscomplete_rosmsg {
    local opts
    reply=()

    if [[ ${CURRENT} == 2 ]]; then
        opts="show list md5 package packages"
        reply=(${=opts})
    elif [[ ${CURRENT} == 3 ]]; then
        case ${=${(s: :)words}[2]} in
            show|users|md5)
                opts=`_msg_opts ${=${(s: :)words[-1]}}`
                reply=(${=opts})
                ;;
            package)
                opts=`rospack list-names`
                reply=(${=opts})
                ;;
            packages|list)
                # This shouldn't really have a completion rule
                ;;
        esac
    fi
}

function _srv_opts {
    local pkgname srvname searchsrv pkgs count opts pkgpath result
    unset searchsrv

    if [[ $1 =~ .+/.* ]]; then
        pkgname=${1%%/*}
        srvname=${1#*/}
        searchsrv=1
    else
        pkgname=${1}
    fi

    if [[ -z ${searchsrv} ]]; then
        pkgs=`command rospack list | grep "^${pkgname}"`
        count=0

        opts=""

        for pkg in ${(f)pkgs}; do
            pkgdir=${=${(s: :)pkg}[2]}
            if [[ -d $pkgdir/srv ]]; then
                pkgname2=${=${(s: :)pkg}[1]}
                opts="$opts $pkgname2/"
                count=$((count+1))
            fi
        done

        if [[ $count > 0 ]]; then
            echo $opts
            return 0
        fi
    fi

    pkgpath=`rospack find ${pkgname} 2> /dev/null`
    if [[ $?  == 0 ]] && [[ -d ${pkgpath}/srv ]]; then
        result=`find -L ${pkgpath}/srv -maxdepth 1 -mindepth 1 -name \*.srv ! -regex ".\*/[.].\*" -print0 | tr '\000' '\n' | sed -e "s/.*\/\(.*\)\.srv/${pkgname}\/\1/g"`
        echo $result
    fi
}

function _roscomplete_rossrv {
    local opts
    reply=()

    if [[ ${CURRENT} == 2 ]]; then
        opts="show list md5 package packages"
        reply=(${=opts})
    elif [[ ${CURRENT} == 3 ]]; then
        case ${=${(s: :)words}[2]} in
            show|users|md5)
                opts=`_srv_opts ${=${(s: :)words[-1]}}`
                reply=(${=opts})
                ;;
            package)
                opts=`rospack list-names`
                reply=(${=opts})
                ;;
            packages|list)
                # This shouldn't really have a completion rule
                ;;
        esac
    fi
}

function _roscomplete_roscreate_pkg {
    local opts
    reply=()

    if [[ ${CURRENT} > 2 ]]; then
        opts=`rospack list-names`
        reply=(${=opts})
    fi
}

compctl -K "_roscomplete_sub_dir" -S / "roscd" "rospd" "rosls"
compctl -K "_roscomplete_rosmake" "rosmake"

compctl -x 'p[1]' -k "(check purge)" -- "rosclean"
compctl -f -x 'p[1]' -K "_roscomplete" - 'p[2]' -K _roscomplete_file -- "rosed" "roscp"
compctl -f -x 'S[-]' -k '(--debug --prefix)' - 'c[-1,--prefix][-1,-p]' -h '' - 'p[1],c[-1,-d],c[-1,--debug],c[-2,-p],c[-2,--prefix]' -K "_roscomplete" - 'p[2],c[-2,-d],c[-2,--debug],c[-3,-p],c[-3,--prefix]' -K _roscomplete_exe -- "rosrun"
compctl -/g '*.(launch|test)' -x 'p[1]' -K "_roscomplete" -tx - 'p[2]' -K _roscomplete_launchfile -- + -x 'S[--]' -k "(--files --args --nodes --find-node --child --local --screen --server_uri --run_id --wait --port --core --pid --dump-params)" -- "roslaunch"
compctl -/g '*.(launch|test)' -x 'p[1]' -K "_roscomplete" -tx - 'p[2]' -K _roscomplete_launchfile -- + -x 'S[--]' -k "(--bare --bare-limit --bare-name --pkgdir --package)" -- "rostest"
compctl -K "_roscomplete_rospack" "rospack"
compctl -K "_roscomplete_rosbag" + -g "*.bag *(/)" "rosbag"
compctl -K "_roscomplete_rosnode" "rosnode"
compctl -K "_roscomplete_rosparam" "rosparam"
compctl -x 'p[0,2]' -K "_roscomplete_rostopic" - 'n[1,/] p[3]' -K "_roscomplete_rostopic" - 'p[3]' -S ' ' -K "_roscomplete_rostopic" - 'p[4]' -Q -K "_roscomplete_rostopic" -- "rostopic"
compctl -K "_roscomplete_rosservice" "rosservice"
compctl -x 'p[1]' -k "(md5 package packages show users)" - 'p[2]' -S '' -K "_roscomplete_rosmsg" -- "rosmsg"
compctl -x 'p[1]' -k "(md5 package packages show users)" - 'p[2]' -S '' -K "_roscomplete_rossrv" -- "rossrv"
compctl -K "_roscomplete_roscreate_pkg" "roscreate-pkg"
compctl -/g '*.(launch|test)' -x 'S[--]' -k "(--all --no-plugins --offline)" -- "roswtf"