unpack

#!/bin/bash
#
# Unpacks one of several different types of archive to the current
# directory.  If there is more than one entry in the top-level
# directory, automatically creates a new subdirectory and unpacks to
# that, in order to avoid filling the current directory with crap.
# In every case, informs the user where the unpacked contents ended up.
#
# Adam Spiers <shell-hacks@adamspiers.org>

me="`basename $0`"

warn () {
    echo >&2 "$*"
}

die () {
    warn "$*"
    exit 1
}

abort () {
    die "$*; aborting."
}

interactive_mode () {
    [ -t 1 ]
}

progress () {
    if interactive_mode; then
        echo "$@"
    fi
}

usage () {
    cat <<EOF >&2
Usage: $me ARCHIVE [ARCHIVE ...]

Unpacks the given archive(s).  Supported formats include:

  tar (incl. compressed with gzip, bzip2, xz), zip, 7z, rar,
  apk, xpi, jar, class, gem, box, rpm, egg

Guarantees that extraction will always be to a newly-created directory
rather than polluting an existing one with multiple entries.

If STDOUT is not a tty, only the name of the new directory containing
the unpacked archive will be output to STDOUT.  This can then be
captured and reused programmatically in other scripts.
EOF
    exit 1
}

parse_options () {
    if [ "$1" == -h ] || [ "$1" == --help ] || [ -z "$1" ]; then
        usage
    fi

    ARGV=( "$@" )
}

unpack () {
    archive_path="$1"
    archive="`basename \"$1\"`"

    get_base_dest_dir
    extract
    cd "$saved_dir"
    ensure_single_dir

    progress "Look inside $dest_dir"
    if ! [ -t 1 ]; then
        echo "$dest_dir"
    fi
}

# Calculate a destination directory for the extracted archive which is
# based on the basename of the archive filename (i.e. with the suffix
# stripped off).
#
# We do this because if we're extracting an archive file called
# "server27-logs.tar.xz" then the user would probably prefer the
# resulting top-level directory to be called "server27-logs" which is
# more informative than just "var", assuming that the archive only
# contained files under the var/log/ hierarchy.  This is especially
# helpful if the user is also unpacking server28-logs.tar.xz and
# server29-logs.tar.xz at the same time, since they can't all be
# extracted to the same "var" directory.
#
# On the other hand, we won't always use this destination directory.
# Sometimes the user prefers to use the singleton top-level directory
# within the archive.  For example if we were extracting an archive
# file called "linux.tar.bz2", we would prefer the resulting top-level
# directory to be called "linux-4.9-rc5" which is more informative
# than just "linux".
#
# Unfortunately we can't always be sure which the user would prefer.
# But a fairly decent heuristic is to pick the longer of the two
# options, since that will usually be more informative and/or more
# likely to uniquely identify the extracted contents.
get_base_dest_dir () {
    base_dest_dir=
    case "$archive" in
        *.tar|*.tgz|*.tbz|*.txz|*.zip|*.Zip|*.ZIP|\
        *.7z|*.apk|*.rar|*.xpi|*.jar|*.sar|*.class|\
        *.job|*.pylib|*.gem|*.box|*.rpm|*.egg|*.cpio)
            base_dest_dir="${archive%.*}"
            ;;
        *.tar.gz)
            base_dest_dir="${archive%.tar.gz}"
            ;;
        *.tar.bz2)
            base_dest_dir="${archive%.tar.bz2}"
            ;;
        *.tar.xz)
            base_dest_dir="${archive%.tar.xz}"
            ;;
        *)
            abort "$archive does not have a supported file extension"
            ;;
    esac
}

# Runs external commands, redirecting output as required.
run () {
    if interactive_mode; then
        "$@"
    else
        "$@" >&2
    fi
}

extract () {
    if ! tmpdir=`mktemp -d "$base_dest_dir.tmp.XXXXXXXX"`; then
        die "mktemp failed: $!"
    fi

    case "$archive" in
        *.tar)
            run tar -C "$tmpdir" -xvf "$archive_path"
            ;;
        *.tar.gz|*.tgz|*.box)
            run tar -C "$tmpdir" -zxvf "$archive_path"
            ;;
        *.tar.bz2|*.tbz)
            run tar -C "$tmpdir" -jxvf "$archive_path"
            ;;
        *.tar.xz|*.txz)
            run tar -C "$tmpdir" -Jxvf "$archive_path"
            ;;
        *.zip|*.ZIP|*.Zip|*.xpi|*.jar|*.class|*.sar|*.job|*.pylib|*.apk|*.egg)
            run unzip -d "$tmpdir" "$archive_path"
            ;;
        *.7z)
            run 7za x -o"$tmpdir" "$archive_path"
            ;;
        *.gem)
            run gem unpack --target="$tmpdir" "$archive_path"
            ;;
        *.rar)
            archive_abspath=$( abs "$archive_path" )
            pushd "$tmpdir"
            run unrar x "$archive_abspath"
            popd
            ;;
        *.cpio)
            cpio_name="$(basename -s .cpio $archive_path)"
            unpack_cpio "$archive_path" "$cpio_name" "$tmpdir"
            ;;
        *.rpm)
            rpm_name="$(basename -s .rpm $archive_path)"
            cpio="$rpm_name.cpio"

            progress -n "Extracting cpio to $tmpdir/$cpio ... "
            rpm2cpio "$rpm" > "$tmpdir/$cpio"
            progress "done."

            unpack_cpio "$tmpdir" "$cpio" "$tmpdir/$rpm_name"
            rm "$tmpdir/$cpio"
            ;;
        *)
            abort "$archive is not a supported archive format"
            ;;
    esac

    if [ $? != 0 ]; then
        abort "Unpack of $archive_path failed"
    fi
}

# Takes a cpio $cpio currently sitting in $cpio_dir and unpacks it into
# $dest
unpack_cpio () {
    cpio_dir="$1"
    cpio="$2"
    dest_dir="$3"

    mkdir "$tmpdir/$cpio_name"
    pushd "$tmpdir/$cpio_name" >/dev/null
    progress "Unpacking contents of $cpio into $tmpdir ... "
    cpio -id < ../"$cpio"
    ret=$?
    if [ $ret != 0 ]; then
        popd
        return $ret
    fi
    progress "done."
    popd >/dev/null
    return 0
}

ensure_single_dir () {
    num_dirents=$( ls -A "$tmpdir" | wc -l )

    if [ "$num_dirents" -eq 0 ]; then
        die "$archive was empty?  Aborting"
    fi

    if [ "$num_dirents" -gt 1 ]; then
        # Naughty archive creator!  Would cause a mess if unpacked to cwd.
        progress "$archive had more than one top-level entry"
        unpacked_dir="$tmpdir"
    else
        top_dir=$( ls -A "$tmpdir" )
        progress "$archive is clean; everything under a single top-level directory $top_dir/"
        unpacked_dir="$tmpdir/$top_dir"
        if [ -e "$top_dir" ]; then
            warn "$top_dir already exists; won't unpack into that."
            # Try to unpack to base destination
        else
            # We can either keep the existing top-level directory, or
            # try to rename to the base destination directory.  As per
            # the lengthy comment above, let's try a heuristic which
            # chooses the longer of the two options.
            if [ "${#top_dir}" -gt "${#base_dest_dir}" ]; then
                if mv "$unpacked_dir" .; then
                    dest_dir="$top_dir"
                    rmdir "$tmpdir"
                    return
                else
                    abort "mv $unpacked_dir . failed"
                fi
            fi
        fi
    fi

    # If we got this far, we decided not to keep the top-level
    # directory from within the archive, so try to rename to the base
    # destination directory.
    calc_dest_dir
    rename_to_dest_dir
}

calc_dest_dir () {
    if ! [ -e "$base_dest_dir" ]; then
        # safe to use base destination directory
        dest_dir="$base_dest_dir"
    else
        warn "Destination $base_dest_dir already exists"
        dest_dir="$archive.unpacked"
        if [ -e "$dest_dir" ]; then
            warn "$dest_dir also already exists"
            # Couldn't find a better place to move unpacked directory to, so
            # leave it where it already is.
            dest_dir="$unpacked_dir"
        fi
    fi
}

rename_to_dest_dir () {
    if [ "$unpacked_dir" != "$dest_dir" ]; then
        #progress "mv $unpacked_dir $dest_dir OK"
        if ! mv "$unpacked_dir" "$dest_dir"; then
            abort "mv $unpacked_dir $dest_dir failed"
        fi
        [ -d "$tmpdir" ] && rmdir "$tmpdir"
    fi
}

main () {
    parse_options "$@"

    saved_dir="`pwd`"

    for archive in "${ARGV[@]}"; do
        if ! [ -e "$archive" ]; then
            abort "$archive does not exist"
        fi
    done

    for archive in "${ARGV[@]}"; do
        unpack "$archive"
    done
}

main "$@"