Bernd Eggink

Editing variables (2)

Functions: To distinguish functions from variables, each function name must be preceded by -f, -F or -p. The function doesn't have to exist yet. If necessary, an empty function definition is generated. The options correspond to different modes:

-f name: Pure temporary editing. Usable for generating and testing small functions on the fly, and restricted to bash. Bash can reproduce internally saved functions as text, formatted in a bash-specific way. This format doesn't look very pretty, but it works anyway. All function definitions are put into a single file, together with the variable settings.
In contrast to bash, ksh can only print the text of a function if the file it has been read from exists. Without the source file, the function may still be called, but no longer reproduced in text form, so using a temporary file doesn't make sense here. Consequently, in the ksh version option -f works the same as -F (see below).
-F name: Editing using a permanent file. This is necessary if you want to change a function in different shell sessions. Instead of putting it in a temporary file, the text is saved in in a file named after the function in a special diretory. The directory's path can be assigned to the variables BASH_VARED_FDIR or KSH_VARED_FDIR, respetively. The defaults are ~/bash-funcs and ~/ksh-funcs. No source file in this directory is deleted automatically, this has to be done by the user. Note that if editing a function defined elsewhere, two versions exist in parallel - the original and the one created by vared. If the original version is loaded during logon, it will be the one that is active, but any following vared call activates the changed one. Thus a function can be edited step by step without touching the original version.
-p name or -p path: Direct editing of a function source. If the parameter is a simple name, the source will be looked up using $FPATH. If it isn't (i.e., it contains at least one '/'), it is considered the path of the source. Here, in contrast to (2), the "official" version of the function is changed, so be careful.

Bash version

# Edit variables interactively (bash version)

# vared {varname | arrayname[index] | -a arrayname | {-f|-F} funcname | -p {funcname|path} }...

shopt -s extglob

#-----------------------------------------------------------------------

function vared  
{ 
    local vared_dcl_ vared_dir_ vared_editfiles_ vared_file_ 
    local vared_found_ vared_funcdir_ vared_funcname_ 
    local vared_i_ vared_indexed_ 
    local -a vared_indices_
    local vared_isfunc_ vared_n_
    local vared_IFS_=$IFS vared_editIFS_
    local vared_defaultFile_=$(mktemp vared.XXXXX)

    trap 'rm -f $vared_defaultFile_' RETURN

    while [[ $1 ]]
    do
        vared_indexed_=
        vared_isfunc_=
        vared_funcname_=

        case $1 in
        (-a)    vared_indexed_=1
                shift
                ;;
        (-f)    vared_isfunc_=1
                shift
                ;;
        (-F)    vared_isfunc_=2
                shift
                ;;
        (-p)    vared_isfunc_=3
                shift
                ;;
        (-h)    cat <<EOF
Usage: ${FUNCNAME[0]} [-h] {name|name[index]|-a name|{-f|-F} name|-p {name|path}}...
     -a: Indexed array 'name' is written in indexed form.
     -f: 'name' is a function name. 
     -F: 'name' is a function name; keep the file /tmp/_vared_/name. 
     -p: Edit existing source.
         If the next parameter is a name, look it up using FPATH.
         Otherwise it must be the path of a function file.
     -h: This help.

An edited file will be sourced.
EOF
                return 0
                ;;
        (*\[*\]|[[:alpha:]]*([[:word:]]))
                :
                ;;
        (*)     printf "+++ not a name: %s\n" "$1" >&2
                shift
                continue
        esac

        # write current settings to tmp file

        if [[ $1 == *\[*\] ]]
        then        
            ### array element

            vared_out_ $1 "${!1}" $'\n' >> $vared_defaultFile_
        elif [[ $vared_isfunc_ ]]
        then
            ### function

            [[ $1 == */* ]] && vared_isfunc_=3

            vared_funcname_=${1##*/}

            case $vared_isfunc_ in
            (1)     # Name supplied, declaration default file

                    if [[ $(declare -F $1) ]]
                    then
                        declare -f $1
                    else
                        printf "function %s\n{\n    :\n}\n" "$vared_funcname_"
                    fi >> $vared_defaultFile_
                    ;;

            (2)     # Name supplied, decl in dedicated tmp file

                    vared_funcdir_=${BASH_VARED_FDIR:-~/bash-funcs}
                    mkdir -p $vared_funcdir_

                    if [[ $(declare -F $1) ]]       # dup!
                    then
                        declare -f $1
                    else
                        printf "function %s\n{\n    :\n}\n" "$vared_funcname_"
                    fi > $vared_funcdir_/$1

                    vared_editfiles_+="$vared_funcdir_/$1" 
                    ;;
    
            (3)     # Path or name supplied
                    
                    if [[ $1 == */* ]]
                    then
                        # path

                        [[ ! -s $1 ]] && printf "function %s\n{\n    :\n}\n" "$vared_funcname_" > $1

                        vared_editfiles_+=" $1"
                    else
                        # name, lookup

                        vared_found_=
                        IFS=:

                        for vared_dir_ in ${FPATH:=$PATH}      # lookup
                        do
                            vared_file_=$vared_dir_/$1

                            if [[ -f $vared_file_ ]]
                            then
                                vared_editfiles_+=" $vared_file_"
                                vared_found_=1
                                break
                            fi
                        done

                        IFS=$' \t\n'

                        [[ ! $vared_found_ ]] &&
                        {
                            printf "+++ unknown function: %s\n" "$1"
                            continue
                        }
                    fi
            esac
        else    
            ### not a function

            vared_dcl_=$(declare -p $1 2>/dev/null)

            case $vared_dcl_ in
            (declare\ -A*)
                ### assoc array

                vared_dcl_=${vared_dcl_#declare -A }
                printf "${vared_dcl_//\'/}\n" >> $vared_defaultFile_
                ;;

            (declare\ -a*)      
                ### indexed array                    

                eval 'vared_n_=${#'$1'[*]}'

                [[ ! $vared_indexed_ ]] && (( vared_n_ )) &&
                {
                    # check for index holes
 
                    eval 'vared_indices_=(${!'$1'[*]})'
                    (( vared_n_ != ${vared_indices_[vared_n_-1]} + 1 )) && vared_indexed_=1
                }
                
                if [[ $vared_indexed_ ]]
                then                    # print indexed
                    vared_dcl_=${vared_dcl_#declare -a }
                    printf "${vared_dcl_//\'/}\n"
                else                    # print normal
                    printf "%s=( " "$1"

                    for (( vared_i_ = 0; vared_i_ < vared_n_; ++vared_i_ ))
                    do
                        eval 'vared_dcl_=${'$1'['$vared_i_']}'
                        vared_out_ '' "$vared_dcl_" ' '
                    done

                     printf ")\n"
                fi >> $vared_defaultFile_
                ;;

            ('')
                ### not set 

                printf "%s=\n" "$1" >> $vared_defaultFile_
                ;;

            (declare\ -?\ *)     
                ### scalar 

                [[ $1 == IFS ]] && vared_editIFS_=1

                vared_out_ $1 "${!1}" $'\n' >> $vared_defaultFile_
                ;;

            (*) 
                ### other

                printf "%s\n" "$vared_dcl_" >> $vared_defaultFile_
                ;;
            esac
        fi

        shift
    done 

    [[ -s $vared_defaultFile_ ]] && vared_editfiles_="$vared_defaultFile_ $vared_editfiles_"

    [[ $vared_editfiles_ ]] && 
    {
        ${EDITOR:-vi} $vared_editfiles_         # edit tmp files

        for vared_file_ in $vared_editfiles_    # source them
        do
            source $vared_file_
        done
    }

    [[ ! $vared_editIFS_ ]] && IFS=$vared_IFS_
    rm -f $vared_defaultFile_
    return 0
}

#-----------------------------------------------------------------------

function vared_out_
{
    local c name=$1 value=$2 out special
    while [[ $value ]]
    do
        c=${value:0:1}

        case $c in
        ($'\a')     out+='\a'
                    special=1
                    ;;
        ($'\b')     out+='\b'
                    special=1
                    ;;
        ($'\f')     out+='\f'
                    special=1
                    ;;
        ($'\n')     out+='\n'
                    special=1
                    ;;
        ($'\r')     out+='\r'
                    special=1
                    ;;
        ($'\t')     out+='\t'
                    special=1
                    ;;
        ($'\v')     out+='\v'
                    special=1
                    ;;
        ($'\\')     out+='\\'
                    special=1
                    ;;
        ($'\'')     out+="\\'"
                    special=1
                    ;;
        (*)         out+=$c
        esac

        value=${value#?}
    done

    if [[ $special ]]
    then
        printf "%s${name:+=}\$'%s'%s" "$name" "$out" "$3"
    else
        printf "%s${name:+=}'%s'%s" "$name" "$out" "$3"
    fi
}

#-----------------------------------------------------------------------

# Completion

complete -v vared

# vim: set filetype=sh

Ksh version

# Edit variables interactively (ksh version)

# vared {varname|arrayname[index]|[-a] arrayname|[-f] funcname}...

function vared_usage_
{
    print "Usage: vared [-h] {name|name[index]|-a name|{-f|-F} name|-p {name|path}}..."
    print "     -a: Array 'name' is written in indexed form."
    print "     -f, -F: 'name' is a function name." 
    print "     -p: Edit existing source."
    print "         If the next parameter is a name, look it up using FPATH."
    print "         Otherwise it is must be the path of a function file."
    print "     -h: This help."
}

#-----------------------------------------------------------------------

vared()
{
    typeset vared_dcl_ vared_edit_ vared_funcdir_ 
    typeset vared_i_ vared_indexed_ 
    typeset vared_indices_ vared_isfunc_ vared_n_ 
    typeset vared_tmpfile_=$(mktemp -p ${TMPDIR:-~}/ vared-XXXXX)
    typeset vared_vartype_ 
    typeset -a vared_editfiles_ vared_funcnames_ 

    [[ $1 == -h ]] &&
    {
        vared_usage_
        return
    }

    # functions directory
    
    vared_funcdir_=${KSH_VARED_FDIR:=~/ksh-funcs}

    mkdir -p $vared_funcdir_
    
    # write current settings to tmp file

    > $vared_tmpfile_

    while [[ $1 ]]
    do
        vared_indexed_= 
        vared_isfunc_=

        case $1 in
        (-a)    vared_indexed_=1
                shift
                ;;
        (-f|-F) vared_isfunc_=2
                shift
                ;;
        (-p)    vared_isfunc_=3
                shift
                ;;
        (*\[*\]|[[:alpha:]_]*([[:word:]]))
                :
                ;;
        (*)     print -u2 "+++ not a name: $1"
                shift
                continue
        esac

        typeset -n vared_ref_=$1

        # array element?

        if [[ $1 == *\[*\] ]]
        then        
            ### array element

            print "$1='$vared_ref_'" >> $vared_tmpfile_
            vared_edit_=1
        elif [[ $vared_isfunc_ ]]
        then
            ### function

            case $vared_isfunc_ in
            (2)     # Name supplied, put declaration in special directory

                    vared_dcl_=$(vared_func_ $1)    # get declaration

                    if [[ $vared_dcl_ == "function $1" || $vared_dcl_ == "$1()" ]]
                    then
                        print -u2 "+++ $vared_dcl_: Text not available"
                    else
                        print "$vared_dcl_" > $vared_funcdir_/$1
                        vared_funcnames_+=($vared_funcdir_/$1)
                    fi
                    ;;
            (3)     # Path or name supplied, edit in-place
                    
                    if [[ $1 == */* ]]
                    then
                        # path

                        [[ ! -e $1 ]] &&
                        {
                            echo "+++ file doesn't exist: $1" >&2
                            shift
                            continue
                        }

                        vared_funcnames_+=($1)
                    else
                        # name, look up

                        vared_found_=
                        IFS=:

                        for vared_dir_ in $FPATH      # lookup
                        do
                            vared_file_=$vared_dir_/$1

                            if [[ -f $vared_file_ ]]
                            then
                                vared_funcnames_+=("$vared_file_")
                                vared_found_=1
                                break
                            fi
                        done

                        IFS=$' \t\n'

                        [[ ! $vared_found_ ]] &&
                        {
                            echo "+++ unknown function: $1"
                            continue
                        }
                    fi
                    ;;
            esac
        else
            vared_edit_=1

            # attributed?

            vared_vartype_=$(typeset | grep " $1\$")

            if [[ $vared_vartype_ == *\ array\ * ]] 
            then
                case $vared_vartype_ in

                (indexed\ array\ *)
                    vared_n_=${#vared_ref_[*]}
                    vared_indices_=(${!vared_ref_[*]})

                    (( vared_n_ && vared_n_ != ${vared_indices_[vared_n_ - 1]} + 1 )) && 
                        vared_indexed_=1

                    if [[ ! $vared_indexed_ ]] 
                    then
                        # normal form
                         
                        print -n "typeset -a $1=( "

                        for vared_i_ in ${vared_indices_[*]}
                        do
                            print -n "'${vared_ref_[vared_i_]}' "
                        done

                        print ")"
                    else
                        # indexed form
                        
                        print -n "typeset -a $1=("

                        for vared_i_ in ${!vared_ref_[*]}
                        do
                            print -n " [$vared_i_]='${vared_ref_[vared_i_]}'"
                        done

                        print " )"
                    fi >> $vared_tmpfile_
                    ;;

                (associative\ array\ *)
                    {
                        print "typeset -A $1=("

                        for vared_i_ in ${!vared_ref_[*]}
                        do
                            print "[$vared_i_]='${vared_ref_[$vared_i_]}'"
                        done

                        print ")"
                    } >> $vared_tmpfile_
                    ;;
                esac
            else
                # scalar or unknown
                    
                vared_edit_=1
                {  
                    set | grep "^$1=" || 
                    {
                        if [[ $vared_indexed_ ]] 
                        then
                            print "typeset -a $1=()"
                        else
                            print "$1="
                        fi
                    }
                } >> $vared_tmpfile_
            fi
        fi
        shift
    done 

    [[ $vared_edit_ ]] && vared_editfiles_[0]=$vared_tmpfile_

    vared_editfiles_+=("${vared_funcnames_[@]}")

    (( ${#vared_editfiles_[*]} )) &&
    {
        ${EDITOR:-vi} "${vared_editfiles_[@]}"          # edit

        for vared_i_ in "${vared_editfiles_[@]}"        # source files
        do
            source $vared_i_
        done
    }

    rm $vared_tmpfile_          # remove tmpfile, leave function files
    typeset +n vared_ref_ 
    unset vared_dcl_ vared_edit_ vared_editfiles_ 
    unset vared_funcdir_ vared_funcnames_ 
    unset vared_i_ vared_indexed_ vared_indices_ vared_isfunc_ vared_n_ 
    unset vared_ref_ vared_tmpfile_ vared_vartype_ 
}

#-----------------------------------------------------------------------

function vared_func_
{
    # Print function definition
 
    typeset name=$1
    typeset res=$(typeset +f $name)     # check if defined

    if [[ $res ]]  
    then
        # Function is defined, get its content
 
        typeset -f $name
    else
        # Function not defined, look up via FPATH

        typeset fdir path pdir
        typeset IFS=:

        for fdir in $FPATH
        do
            for pdir in $PATH
            do
                [[ $pdir == $fdir ]] &&
                {
                    [[ -e $fdir/$name ]] &&
                    {
                        # found 

                        cat $fdir/$name                        
                        return
                    }

                    continue 2
                }
            done
        done

        # Not found, create empty function
 
        print "function $name\n{\n    :\n}"
    fi
}