From: George Ogata <george.ogata@...>
Date: 2007-03-03T21:33:02+09:00
Subject: Re: [ANN] Bash completion for the gem command

On 2/24/07, Michael Schuerig <michael@schuerig.de> wrote:
>
> To my surprise there apparently hasn't been support for bash command
> line completion for the gem command. I've cobbled together a file that
> add just that. See
>
> http://schuerig.de/michael/blog/index.php/2007/02/24/gem-bash-completion/
>
> I've only tested it on Debian/Linux, on other Linux/Unix variants things
> might work somewhat differently. Also, I don't even try to do
> completion for gem names; doing that for remote gems would be much to
> slow and I haven't looked into getting that information from the local
> source_cache.
>
> Michael

Hi Michael,

Thanks for the script.

I've had a go at hacking in gem name completion for install and
uninstall.  For uninstall it uses installed names, for install it uses
the names in the source cache.  Only tested with gem 0.9.1.

Regards,
George.

----------------------------------------------------------------------

# Michael Schuerig, michael@schuerig.de, 2007-02-24
# George Ogata, george.ogata@gmail.com, 2007-03-01
# Free for all uses.

GEM_CACHE_FILE=`ruby -rubygems -rrubygems/source_info_cache \
                 -e 'print Gem::SourceInfoCache.new.cache_file'`
GEM_AVAILABLE_FILE=`dirname $GEM_CACHE_FILE`/source_cache_names

#
# Output all available gem names.
#
function available_gems {
    if [ ! -e $GEM_AVAILABLE_FILE -o \
         $GEM_CACHE_FILE -nt $GEM_AVAILABLE_FILE ]; then
        ruby <<EOF > $GEM_AVAILABLE_FILE
            require 'rubygems/source_info_cache_entry'
            text = File.read('$GEM_CACHE_FILE')
            names = Marshal.load(text).values.map do |entry|
              entry.source_index.latest_specs.keys
            end.flatten
            puts names.uniq
EOF
    fi

    cat $GEM_AVAILABLE_FILE
}

#
# Output all installed gem names.
#
function installed_gems {
    ruby <<EOF
        require 'rubygems'
        names = Gem::SourceIndex.from_installed_gems.map do |name, spec|
          spec.name
        end.uniq
        puts names
EOF
}

_gem()
{
    local cur prev completions

    COMPREPLY=()
    cur=${COMP_WORDS[COMP_CWORD]}
    prev=${COMP_WORDS[COMP_CWORD-1]}

    COMMANDS='build cert check cleanup contents dependency\
      environment help install list query rdoc search specification\
      uninstall unpack update'

    COMMON_OPTIONS='\
      --source
      -p --http-proxy --no-http-proxy\
      -h --help\
      --config-file\
      --backtrace\
      --debug'

    CERT_OPTIONS='\
      -a -add\
      -l --list\
      -r --remove\
      -b --build\
      -C --certificate\
      -K --private-key\
      -s --sign'

    CHECK_OPTIONS='\
      -v --verify\
      -a --alien\
      -t --test\
      -V --version'

    CLEANUP_OPTIONS='\
      -d --dry-run'

    CONTENTS_OPTIONS='\
      -l --list\
      -V --version\
      -s --spec-dir\
      -v --verbose'

    DEPENDENCY_OPTIONS='\
      -v --version\
      -r --reverse-dependencies --no-reverse-dependencies\
      -p --pipe'

    HELP_OPTIONS=$COMMANDS

    INSTALL_OPTIONS='\
      -v --version\
      -l --local\
      -r --remote\
      -b --both\
      -i --install-dir\
      -B --build-root\
      -d --rdoc --no-rdoc\
      --ri --no-ri\
      -f --force --no-force\
      -t --test --no-test\
      -w --wrappers --no-wrappers\
      -P --trust-policy\
      --ignore-dependencies\
      -y --include-dependencies'

    LIST_OPTIONS='\
      -d --details --no-details\
      -l --local\
      -r --remote\
      -b --both'

    QUERY_OPTIONS='\
      -n --name-matches\
      -d --details --no-details\
      -l --local\
      -r --remote\
      -b --both'

    RDOC_OPTIONS='\
      --all\
      --rdoc --no-rdoc\
      --ri --no-ri\
      -v --version'

    SEARCH_OPTIONS='\
      -d --details --no-details\
      -l --local\
      -r --remote\
      -b --both'

    SPECIFICATION_OPTIONS='\
      -v --version\
      -l --local\
      -r --remote\
      -b --both\
      -all'

    UNINSTALL_OPTIONS='\
      -a --all --no-all\
      -i --ignore-dependencies --no-ignore-dependencies\
      -x --executables --no-executables\
      -v --version'

    UNPACK_OPTIONS='\
      -v --version'

    UPDATE_OPTIONS='\
      -i --install-dir\
      -B --build-root\
      -d --rdoc --no-rdoc\
      -ri --no-ri\
      -f --force --no-force\
      -t --test --no-test\
      -w --wrappers --no-wrappers\
      -P --trust-policy\
      --ignore-dependencies\
      -y --include-dependencies\
      --system'

    case "${prev}" in
      build)
        completions="$COMMON_OPTIONS $BUILD_OPTIONS"
        ;;
      cert)
        completions="$COMMON_OPTIONS $CERT_OPTIONS"
        ;;
      check)
        completions="$COMMON_OPTIONS $CHECK_OPTIONS"
        ;;
      cleanup)
        completions="$COMMON_OPTIONS $CLEANUP_OPTIONS"
        ;;
      contents)
        completions="$COMMON_OPTIONS $CONTENTS_OPTIONS"
        ;;
      dependency)
        completions="$COMMON_OPTIONS $DEPENDENCY_OPTIONS"
        ;;
      environment)
        completions="$COMMON_OPTIONS $ENVIRONMENT_OPTIONS"
        ;;
      help)
        completions="$COMMON_OPTIONS $HELP_OPTIONS"
        ;;
      install)
        completions="$COMMON_OPTIONS $INSTALL_OPTIONS `available_gems`"
        ;;
      list)
        completions="$COMMON_OPTIONS $LIST_OPTIONS"
        ;;
      query)
        completions="$COMMON_OPTIONS $QUERY_OPTIONS"
        ;;
      rdoc)
        completions="$COMMON_OPTIONS $RDOC_OPTIONS"
        ;;
      search)
        completions="$COMMON_OPTIONS $SEARCH_OPTIONS"
        ;;
      specification)
        completions="$COMMON_OPTIONS $SPECIFICATION_OPTIONS"
        ;;
      uninstall)
        completions="$COMMON_OPTIONS $UNINSTALL_OPTIONS `installed_gems`"
        ;;
      unpack)
        completions="$COMMON_OPTIONS $UNPACK_OPTIONS"
        ;;
      update)
        completions="$COMMON_OPTIONS $UPDATE_OPTIONS"
        ;;
      *)
        completions="$COMMANDS $COMMON_OPTIONS"
        ;;
    esac

    COMPREPLY=( $( compgen -W "$completions" -- $cur ))
    return 0
}

[ -n "${have:-}" ] && complete -F _gem $filenames gem