{Ninja-Shell}

Filename: ///usr/share///bash-completion/completions//pvchange

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

_lvm_filedir()
{
    cur=${cur:-/dev/}
    _filedir
}

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

_lvm_physicalvolumes_all()
{
    COMPREPLY=($(compgen -W "$(pvscan 2>/dev/null |
        command sed -n -e 's|^.*PV $[^ ]*$ .*|\1|p')" -- "$cur"))
}

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

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

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

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

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

_lvmdiskscan()
{
    local cur prev words cword
    _init_completion || return

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

_pvscan()
{
    local cur prev words cword
    _init_completion || return

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    fi
} &&
    complete -F _pvscan pvscan

_pvs()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --options | --sort | -!(-*)[oO])
            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
            ;;
        --units)
            _lvm_units
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_physicalvolumes_all
    fi
} &&
    complete -F _pvs pvs

_pvdisplay()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --units)
            _lvm_units
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_physicalvolumes_all
    fi
} &&
    complete -F _pvdisplay pvdisplay

_pvchange()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | --allocatable | -!(-*)[Ax])
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_physicalvolumes_all
    fi
} &&
    complete -F _pvchange pvchange

_pvcreate()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --restorefile)
            _filedir
            return
            ;;
        --metadatatype | -!(-*)M)
            COMPREPLY=($(compgen -W '1 2' -- "$cur"))
            return
            ;;
        --metadatacopies)
            COMPREPLY=($(compgen -W '0 1 2' -- "$cur"))
            return
            ;;
        --metadatasize | --setphysicalvolumesize)
            _lvm_sizes
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_filedir
    fi
} &&
    complete -F _pvcreate pvcreate

_pvmove()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
        --name | -!(-*)n)
            _lvm_logicalvolumes
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_physicalvolumes
    fi
} &&
    complete -F _pvmove pvmove

_pvremove()
{
    local cur prev words cword
    _init_completion || return

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_physicalvolumes_all
    fi
} &&
    complete -F _pvremove pvremove

_vgscan()
{
    local cur prev words cword
    _init_completion || return

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

_vgs()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --options | --sort | -!(-*)[oO])
            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
            ;;
        --units)
            _lvm_units
            return
            ;;
    esac

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

_vgdisplay()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --units)
            _lvm_units
            return
            ;;
    esac

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

_vgchange()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --available | --autobackup | --resizeable | -!(-*)[aAx])
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        _lvm_volumegroups
    fi
} &&
    complete -F _vgchange vgchange

_vgcreate()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
        --metadatatype | -!(-*)M)
            COMPREPLY=($(compgen -W '1 2' -- "$cur"))
            return
            ;;
        --physicalextentsize | -!(-*)s)
            _lvm_sizes
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        local args
        _lvm_count_args '@(-A|--autobackup|-M|--metadatatype|-s|--physicalextentsize)'
        if ((args == 0)); then
            _lvm_volumegroups
        else
            _lvm_physicalvolumes_all
        fi
    fi
} &&
    complete -F _vgcreate vgcreate

_vgremove()
{
    local cur prev words cword
    _init_completion || return

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

_vgrename()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

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

_vgreduce()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

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

else
        local args
        _lvm_count_args '@(-A|--autobackup)'
        if ((args == 0)); then
            _lvm_volumegroups
        else
            _lvm_physicalvolumes
        fi
    fi
} &&
    complete -F _vgreduce vgreduce

_vgextend()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
        --size | -!(-*)L)
            _lvm_sizes
            return
            ;;
    esac

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

_vgport()
{
    local cur prev words cword
    _init_completion || return

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

_vgck()
{
    local cur prev words cword
    _init_completion || return

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

_vgconvert()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --metadatatype | -!(-*)M)
            COMPREPLY=($(compgen -W '1 2' -- "$cur"))
            return
            ;;
        --metadatacopies)
            COMPREPLY=($(compgen -W '0 1 2' -- "$cur"))
            return
            ;;
        --metadatasize)
            _lvm_sizes
            return
            ;;
    esac

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

_vgcfgbackup()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --file | -!(-*)f)
            _filedir
            return
            ;;
    esac

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

_vgcfgrestore()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --file | -!(-*)f)
            _filedir
            return
            ;;
        --metadatatype | -!(-*)M)
            COMPREPLY=($(compgen -W '1 2' -- "$cur"))
            return
            ;;
        --name | -!(-*)n)
            _lvm_volumegroups
            return
            ;;
    esac

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

_vgmerge()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

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

_vgsplit()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
        --metadatatype | -!(-*)M)
            COMPREPLY=($(compgen -W '1 2' -- "$cur"))
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        COMPREPLY=($(compgen -W '$(_parse_usage "$1" --help)' -- "$cur"))
    else
        local args
        _lvm_count_args '@(-A|--autobackup|-M|--metadatatype)'
        if ((args == 0 || args == 1)); then
            _lvm_volumegroups
        else
            _lvm_physicalvolumes
        fi
    fi
} &&
    complete -F _vgsplit vgsplit

_vgmknodes()
{
    local cur prev words cword
    _init_completion || return

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

_lvscan()
{
    local cur prev words cword
    _init_completion || return

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

_lvs()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --options | --sort | -!(-*)[oO])
            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
            ;;
        --units)
            _lvm_units
            return
            ;;
    esac

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

_lvdisplay()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --units)
            _lvm_units
            return
            ;;
    esac

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

_lvchange()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --available | --autobackup | --contiguous | --persistent | -!(-*)[aACM])
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
        --permission | -!(-*)p)
            COMPREPLY=($(compgen -W 'r rw' -- "$cur"))
            return
            ;;
    esac

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

_lvcreate()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | --contiguous | --persistent | --zero | -!(-*)[ACMZ])
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
        --size | -!(-*)L)
            _lvm_sizes
            return
            ;;
        --permission | -!(-*)p)
            COMPREPLY=($(compgen -W 'r rw' -- "$cur"))
            return
            ;;
        --name | -!(-*)n)
            _lvm_logicalvolumes
            return
            ;;
    esac

if [[ $cur == -* ]]; then
        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 == 0)); then
            _lvm_volumegroups
        else
            _lvm_physicalvolumes
        fi
    fi
} &&
    complete -F _lvcreate lvcreate

_lvremove()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

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

_lvrename()
{
    local cur prev words cword
    _init_completion || return

case $prev in
        --autobackup | -!(-*)A)
            COMPREPLY=($(compgen -W 'y n' -- "$cur"))
            return
            ;;
    esac

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

_lvreduce()
{
    local cur prev words cword
    _init_completion || return

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

_lvresize()
{
    local cur prev words cword
    _init_completion || return

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

_lvextend()
{
    local cur prev words cword
    _init_completion || return

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

_lvm()
{
    local cur prev words cword
    _init_completion || return

if ((cword == 1)); then
        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
        case "${words[1]}" in
            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]}
                ;;
        esac
    fi
} &&
    complete -F _lvm lvm

# ex: filetype=sh

./Ninja\.