# bash completion for lvm                                  -*- shell-script -*-

proc _lvm_volumegroups
{
    setglobal COMPREPLY = ''( $(compgen -W "$( vgscan 2>/dev/null | \
        sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- "$cur" ) )
}

proc _lvm_physicalvolumes
{
    setglobal COMPREPLY = ''( $(compgen -W "$( pvscan 2>/dev/null | \
        sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- "$cur" ) )
}

proc _lvm_logicalvolumes
{
    setglobal COMPREPLY = ''( $(compgen -W "$( lvscan 2>/dev/null | \
        sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- "$cur" ) )
    if [[ $cur == /dev/mapper/* ]] {
        _filedir
        local i
        for i in [$(!COMPREPLY[@])] {
            [[ ${COMPREPLY[i]} == */control ]] && unset 'COMPREPLY[i]'
        }
    }
}

proc _lvm_units
{
    setglobal COMPREPLY = ''( $( compgen -W 'h s b k m g t H K M G T' -- "$cur" ) )
}

proc _lvm_sizes
{
    setglobal COMPREPLY = ''( $( compgen -W 'k K m M g G t T' -- "$cur" ) )
}

# @param $1 glob matching args known to take an argument
proc _lvm_count_args
{
    setglobal args = '0'
    local offset=1
    if [[ "${words[0]}" == lvm ]] {
        setglobal offset = '2'
    }
    local i prev=$(words[$offset-1])
    for (( i=$offset; i < cword; i++ )); do
        if [[ "${words[i]}" != -* && $prev != $1 ]]; then
            args=$(($args + 1))
        fi
        prev=${words[i]}
    done
}

proc _lvmdiskscan
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    }
} &&
complete -F _lvmdiskscan lvmdiskscan

proc _pvscan
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '--debug --exported --novolumegroup --help
            --ignorelockingfailure --partial --short --uuid --verbose
            --version' -- "$cur" ) )
    }
} &&
complete -F _pvscan pvscan

proc _pvs
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -o|-O|--options|--sort
            setglobal COMPREPLY = ''( $( compgen -W 'pv_fmt pv_uuid pv_size pv_free pv_used
                pv_name pv_attr pv_pe_count pv_pe_alloc_count' -- "$cur" ) )
            return 0
            
        with --units
            _lvm_units
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_physicalvolumes
    }
} &&
complete -F _pvs pvs

proc _pvdisplay
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with --units
            _lvm_units
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_physicalvolumes
    }
} &&
complete -F _pvdisplay pvdisplay

proc _pvchange
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|-x|--autobackup|--allocatable
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_physicalvolumes
    }
} &&
complete -F _pvchange pvchange

proc _pvcreate
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with --restorefile
            _filedir
            return 0
            
        with -M|--metadatatype
            setglobal COMPREPLY = ''( $( compgen -W '1 2' -- "$cur" ) )
            return 0
            
        with --metadatacopies
            setglobal COMPREPLY = ''( $( compgen -W '0 1 2' -- "$cur" ) )
            return 0
            
        with --metadatasize|--setphysicalvolumesize
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_physicalvolumes
    }
} &&
complete -F _pvcreate pvcreate

proc _pvmove
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -n|--name
            _lvm_logicalvolumes
            return 0
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '--abort --autobackup --background --debug
            --force --help --interval --test --verbose --version --name' \
                -- "$cur" ) )
    } else {
        _lvm_physicalvolumes
    }
} &&
complete -F _pvmove pvmove

proc _pvremove
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_physicalvolumes
    }
} &&
complete -F _pvremove pvremove

proc _vgscan
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    }
} &&
complete -F _vgscan vgscan

proc _vgs
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -o|-O|--options|--sort
            setglobal COMPREPLY = ''( $( compgen -W 'vg_fmt vg_uuid vg_name vg_attr vg_size
                vg_free vg_sysid vg_extent_size vg_extent_count vg_free_count
                max_lv max_pv pv_count lv_count snap_count vg_seqno' \
                    -- "$cur" ) )
            return 0
            
        with --units
            _lvm_units
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgs vgs

proc _vgdisplay
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with --units
            _lvm_units
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgdisplay vgdisplay

proc _vgchange
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -a|-A|-x|--available|--autobackup|--resizeable
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '--autobackup --alloc --partial --debug
            --help --ignorelockingfailure --test --uuid --verbose --version
            --available --resizeable --logicalvolume --addtag --deltag' \
                -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgchange vgchange

proc _vgcreate
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -M|--metadatatype
            setglobal COMPREPLY = ''( $( compgen -W '1 2' -- "$cur" ) )
            return 0
            
        with -s|--physicalextentsize
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '--autobackup --addtag --alloc --debug --help
            --maxlogicalvolumes --metadatatype --maxphysicalvolumes
            --physicalextentsize --test --verbose --version' -- "$cur" ) )
    } else {
        local args
        _lvm_count_args '@(-A|--autobackup|-M|--metadatatype|-s|--physicalextentsize)'
        if [[ $args -eq 0 ]] {
            _lvm_volumegroups
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _vgcreate vgcreate

proc _vgremove
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgremove vgremove

proc _vgrename
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgrename vgrename

proc _vgreduce
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )

    } else {
        local args
        _lvm_count_args '@(-A|--autobackup)'
        if [[ $args -eq 0 ]] {
            _lvm_volumegroups
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _vgreduce vgreduce

proc _vgextend
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -L|--size
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        local args
        _lvm_count_args '@(-A|--autobackup|-L|--size)'
        if [[ $args -eq 0 ]] {
            _lvm_volumegroups
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _vgextend vgextend

proc _vgport
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgport vgimport vgexport

proc _vgck
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgck vgck

proc _vgconvert
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -M|--metadatatype
            setglobal COMPREPLY = ''( $( compgen -W '1 2' -- "$cur" ) )
            return 0
            
        with --metadatacopies
            setglobal COMPREPLY = ''( $( compgen -W '0 1 2' -- "$cur" ) )
            return 0
            
        with --metadatasize
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgconvert vgconvert

proc _vgcfgbackup
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -f|--file
            _filedir
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgcfgbackup vgcfgbackup

proc _vgcfgrestore
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -f|--file
            _filedir
            return 0
            
        with -M|--metadatatype
            setglobal COMPREPLY = ''( $( compgen -W '1 2' -- "$cur" ) )
            return 0
            
        with -n|--name
            _lvm_volumegroups
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgcfgrestore vgcfgrestore

proc _vgmerge
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgmerge vgmerge

proc _vgsplit
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -M|--metadatatype
            setglobal COMPREPLY = ''( $( compgen -W '1 2' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '--autobackup --debug --help --list
            --metadatatype --test --verbose --version' -- "$cur" ) )
    } else {
        local args
        _lvm_count_args '@(-A|--autobackup|-M|--metadatatype)'
        if [[ $args -eq 0 || $args -eq 1 ]] {
            _lvm_volumegroups
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _vgsplit vgsplit

proc _vgmknodes
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_volumegroups
    }
} &&
complete -F _vgmknodes vgmknodes

proc _lvscan
{
    local cur prev words cword
    _init_completion || return

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    }
} &&
complete -F _lvscan lvscan

proc _lvs
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -o|-O|--options|--sort
            setglobal COMPREPLY = ''( $( compgen -W 'lv_uuid lv_name lv_attr lv_minor lv_size
                seg_count origin snap_percent segtype stripes stripesize
                chunksize seg_start seg_size' -- "$cur" ) )
            return 0
            
        with --units
            _lvm_units
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_logicalvolumes
    }
} &&
complete -F _lvs lvs

proc _lvdisplay
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with --units
            _lvm_units
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_logicalvolumes
    }
} &&
complete -F _lvdisplay lvdisplay

proc _lvchange
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -a|-A|-C|-M|--available|--autobackup|--contiguous|--persistent
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -p|--permission
            setglobal COMPREPLY = ''( $( compgen -W 'r rw' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_logicalvolumes
    }
} &&
complete -F _lvchange lvchange

proc _lvcreate
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|-C|-M|-Z|--autobackup|--contiguous|--persistent|--zero
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -L|--size
            _lvm_sizes
            return 0
            
        with -p|--permission
            setglobal COMPREPLY = ''( $( compgen -W 'r rw' -- "$cur" ) )
            return 0
            
        with -n|--name
            _lvm_logicalvolumes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        local args
        _lvm_count_args '@(-A|-C|-M|-Z|--autobackup|--contiguous|--persistent|--zero|-L|--size|-p|--permission|-n|--name)'
        if [[ $args -eq 0 ]] {
            _lvm_volumegroups
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _lvcreate lvcreate

proc _lvremove
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_logicalvolumes
    }
} &&
complete -F _lvremove lvremove

proc _lvrename
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_logicalvolumes
    }
} &&
complete -F _lvrename lvrename

proc _lvreduce
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -L|--size
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        _lvm_logicalvolumes
    }
} &&
complete -F _lvreduce lvreduce

proc _lvresize
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -L|--size
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        local args
        _lvm_count_args '@(-A|--autobackup|-L|--size)'
        if [[ $args -eq 0 ]] {
            _lvm_logicalvolumes
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _lvresize lvresize

proc _lvextend
{
    local cur prev words cword
    _init_completion || return

    match $prev {
        with -A|--autobackup
            setglobal COMPREPLY = ''( $( compgen -W 'y n' -- "$cur" ) )
            return 0
            
        with -L|--size
            _lvm_sizes
            return 0
            
    }

    if [[ "$cur" == -* ]] {
        setglobal COMPREPLY = ''( $( compgen -W '$( _parse_usage "$1" --help )' -- "$cur" ) )
    } else {
        local args
        _lvm_count_args '@(-A|--autobackup|-L|--size)'
        if [[ $args -eq 0 ]] {
            _lvm_logicalvolumes
        } else {
            _lvm_physicalvolumes
        }
    }
} &&
complete -F _lvextend lvextend

proc _lvm
{
    local cur prev words cword
    _init_completion || return

    if [[ $cword -eq 1 ]] {
        setglobal COMPREPLY = ''( $( compgen -W 'dumpconfig help lvchange lvcreate lvdisplay
            lvextend lvmchange lvmdiskscan lvmsadc lvmsar lvreduce lvremove
            lvrename lvresize lvs lvscan pvchange pvcreate pvdata pvdisplay
            pvmove pvremove pvresize pvs pvscan vgcfgbackup vgcfgrestore
            vgchange vgck vgconvert vgcreate vgdisplay vgexport vgextend
            vgimport vgmerge vgmknodes vgreduce vgremove vgrename vgs vgscan
            vgsplit version' -- "$cur" ) )
    } else {
        match $(words[1]) {
            with pvchange|pvcreate|pvdisplay|pvmove|pvremove|pvresize|pvs|pvscan|\
            vgcfgbackup|vgcfgrestore|vgchange|vgck|vgconvert|vgcreate|\
            vgdisplay|vgexport|vgextend|vgimport|vgmerge|vgmknodes|vgreduce|\
            vgremove|vgrename|vgs|vgscan|vgsplit|lvchange|lvcreate|lvdisplay|\
            lvextend|lvreduce|lvremove|lvrename|lvresize|lvscan
                _$(words[1])
                
        }
    }
} &&
complete -F _lvm lvm

# ex: ts=4 sw=4 et filetype=sh