find-in-jars

#!/usr/bin/env bash
# @Function
# Find files in the jar files under specified directory, search jar files recursively(include subdirectory).
#
# @Usage
#   $ find-in-jars 'log4j\.properties'
#   # search file log4j.properties/log4j.xml at zip root
#   $ find-in-jars '^log4j\.(properties|xml)$'
#   $ find-in-jars 'log4j\.properties$' -d /path/to/find/directory
#   $ find-in-jars '\.properties$' -d /path/to/find/dir1 -d path/to/find/dir2
#   $ find-in-jars 'Service\.class$' -e jar -e zip
#   $ find-in-jars 'Mon[^$/]*Service\.class$' -s ' <-> '
#
# @online-doc https://github.com/oldratlee/useful-scripts/blob/dev-3.x/docs/java.md#-find-in-jars
# @author Jerry Lee (oldratlee at gmail dot com)
set -eEuo pipefail

readonly PROG=${0##*/}
readonly PROG_VERSION='3.x-dev'

################################################################################
# util functions
################################################################################

readonly COLOR_RESET='\e[0m'

redPrint() {
  # if stdout is a terminal, turn on color output.
  #   '-t' check: is a terminal?
  #   check isatty in bash https://stackoverflow.com/questions/10022323
  if [ -t 1 ]; then
    printf "\e[1;31m%s$COLOR_RESET\n" "$*"
  else
    printf '%s\n' "$*"
  fi
}

# How to delete line with echo?
# https://unix.stackexchange.com/questions/26576
#
# terminal escapes: http://ascii-table.com/ansi-escape-sequences.php
# In particular, to clear from the cursor position to the beginning of the line:
# echo -e "\033[1K"
# Or everything on the line, regardless of cursor position:
# echo -e "\033[2K"
readonly LINE_CLEAR='\e[2K\r'

# Getting console width using a bash script
# https://unix.stackexchange.com/questions/299067
[ -t 2 ] && COLUMNS=$(stty size | awk '{print $2}')

printResponsiveMessage() {
  if ! $show_responsive || [ ! -t 2 ]; then
    return
  fi

  local content=$*
  # http://www.linuxforums.org/forum/red-hat-fedora-linux/142825-how-truncate-string-bash-script.html
  printf %b%s "$LINE_CLEAR" "${content:0:COLUMNS}" >&2
}

clearResponsiveMessage() {
  if ! $show_responsive || [ ! -t 2 ]; then
    return
  fi

  printf %b "$LINE_CLEAR" >&2
}

die() {
  local prompt_help=false exit_status=2
  while (($# > 0)); do
    case "$1" in
    -h)
      prompt_help=true
      shift
      ;;
    -s)
      exit_status=$2
      shift 2
      ;;
    *)
      break
      ;;
    esac
  done

  clearResponsiveMessage
  (($# > 0)) && redPrint "$PROG: $*"
  $prompt_help && echo "Try '$PROG --help' for more information."

  exit "$exit_status"
} >&2

usage() {
  cat <<EOF
Usage: $PROG [OPTION]... PATTERN

Find files in the jar files under specified directory,
search jar files recursively(include subdirectory).
The pattern default is *extended* regex.

Example:
  $PROG 'log4j\.properties'
  # search file log4j.properties/log4j.xml at zip root
  $PROG '^log4j\.(properties|xml)$'
  $PROG 'log4j\.properties$' -d /path/to/find/directory
  $PROG '\.properties$' -d /path/to/find/dir1 -d path/to/find/dir2
  $PROG 'Service\.class$' -e jar -e zip
  $PROG 'Mon[^$/]*Service\.class$' -s ' <-> '

Find control:
  -d, --dir              the directory that find jar files.
                         default is current directory. this option can specify
                         multiply times to find in multiply directories.
  -e, --extension        set find file extension, default is jar. this option
                         can specify multiply times to find multiply extension.
  -E, --extended-regexp  PATTERN is an extended regular expression (*default*)
  -F, --fixed-strings    PATTERN is a set of newline-separated strings
  -G, --basic-regexp     PATTERN is a basic regular expression
  -P, --perl-regexp      PATTERN is a Perl regular expression
  -i, --ignore-case      ignore case distinctions

Output control:
  -a, --absolute-path    always print absolute path of jar file
  -s, --separator        specify the separator between jar file and zip entry.
                         default is \`!'.
  -L, --files-not-contained-found
                         print only names of JAR FILEs NOT contained found
  -l, --files-contained-found
                         print only names of JAR FILEs contained found
  -R, --no-find-progress do not display responsive find progress

Miscellaneous:
  -h, --help             display this help and exit
  -V, --version          display version information and exit
EOF

  exit
}

progVersion() {
  printf '%s\n' "$PROG $PROG_VERSION"
  exit
}

################################################################################
# parse options
################################################################################

dirs=()
extensions=()
args=()

separator='!'
regex_mode=-E
use_absolute_path=false
show_responsive=true
only_print_file_name=false

while (($# > 0)); do
  case "$1" in
  -d | --dir)
    dirs=(${dirs[@]:+"${dirs[@]}"} "$2")
    shift 2
    ;;
  -e | --extension)
    extensions=(${extensions[@]:+"${extensions[@]}"} "$2")
    shift 2
    ;;
  -E | --extended-regexp)
    regex_mode=-E
    shift
    ;;
  -F | --fixed-strings)
    regex_mode=-F
    shift
    ;;
  -G | --basic-regexp)
    regex_mode=-G
    shift
    ;;
  -P | --perl-regexp)
    regex_mode=-P
    shift
    ;;
  -i | --ignore-case)
    ignore_case_option=-i
    shift
    ;;
  -a | --absolute-path)
    use_absolute_path=true
    shift
    ;;
  # support the legacy typo option name --seperator for compatibility
  -s | --separator | --seperator)
    separator=$2
    shift 2
    ;;
  -L | --files-not-contained-found)
    only_print_file_name=true
    print_matched_files=false
    shift
    ;;
  -l | --files-contained-found)
    only_print_file_name=true
    print_matched_files=true
    shift
    ;;
  -R | --no-find-progress)
    show_responsive=false
    shift
    ;;
  -h | --help)
    usage
    ;;
  -V | --version)
    progVersion
    ;;
  --)
    shift
    args=(${args[@]:+"${args[@]}"} "$@")
    break
    ;;
  -*)
    die -h "unrecognized option '$1'"
    ;;
  *)
    args=(${args[@]:+"${args[@]}"} "$1")
    shift
    ;;
  esac
done

readonly separator regex_mode ignore_case_option use_absolute_path only_print_file_name print_matched_files show_responsive args

# shellcheck disable=SC2178
dirs=${dirs:-.}
# shellcheck disable=SC2178
readonly extensions=${extensions:-jar}

((${#args[@]} == 0)) && die -h "requires file pattern!"
((${#args[@]} > 1)) && die -h "more than 1 file pattern: ${args[*]}"
readonly pattern=${args[0]}

tmp_dirs=()
for d in "${dirs[@]}"; do
  [ -e "$d" ] || die "file $d(specified by option -d): No such file or directory!"
  [ -d "$d" ] || die "file $d(specified by option -d) exists but is not a directory!"
  [ -r "$d" ] || die "directory $d(specified by option -d) exists but is not readable!"

  # convert dirs to Absolute Path if has option -a, --absolute-path
  $use_absolute_path && tmp_dirs=(${tmp_dirs[@]:+"${tmp_dirs[@]}"} "$(cd "$d" && pwd)")
done
# set dirs to Absolute Path
$use_absolute_path && dirs=("${tmp_dirs[@]}")
readonly dirs
unset d tmp_dirs

# convert extensions to find -iname options
find_iname_options=()
for e in "${extensions[@]}"; do
  find_iname_options=(${find_iname_options[@]:+"${find_iname_options[@]}" -o} -iname "*.$e")
done
readonly find_iname_options
unset e

################################################################################
# Check the existence of command for listing zip entry!
################################################################################

__prepareCommandToListZipEntries() {
  # `zipinfo -1`/`unzip -Z1` is ~25 times faster than `jar tf`, find zipinfo/unzip command first.
  #
  # How to list files in a zip without extra information in command line
  # https://unix.stackexchange.com/a/128304/136953

  if type -P zipinfo &>/dev/null; then
    command_to_list_zip_entries=(zipinfo -1)
    is_use_zip_cmd_to_list_zip_entries=true
  elif type -P unzip &>/dev/null; then
    command_to_list_zip_entries=(unzip -Z1)
    is_use_zip_cmd_to_list_zip_entries=true
  elif [ -n "$JAVA_HOME" ]; then
    # search jar command under JAVA_HOME
    if [ -f "$JAVA_HOME/bin/jar" ]; then
      [ -x "$JAVA_HOME/bin/jar" ] || die "found \$JAVA_HOME/bin/jar($JAVA_HOME/bin/jar) is NOT executable!"
      command_to_list_zip_entries=("$JAVA_HOME/bin/jar" tf)
    elif [ -f "$JAVA_HOME/../bin/jar" ]; then
      [ -x "$JAVA_HOME/../bin/jar" ] || die "found \$JAVA_HOME/../bin/jar($JAVA_HOME/../bin/jar) is NOT executable!"
      command_to_list_zip_entries=("$JAVA_HOME/../bin/jar" tf)
    fi
    is_use_zip_cmd_to_list_zip_entries=false
  elif type -P jar &>/dev/null; then
    # search jar command under PATH
    command_to_list_zip_entries=(jar tf)
    is_use_zip_cmd_to_list_zip_entries=false
  else
    die "command to list zip entries NOT found : zipinfo, unzip or jar!"
  fi

  readonly command_to_list_zip_entries is_use_zip_cmd_to_list_zip_entries
}
__prepareCommandToListZipEntries

listZipEntries() {
  local zip_file=$1 msg

  if $is_use_zip_cmd_to_list_zip_entries; then
    # How to check if zip file is empty in bash
    # https://superuser.com/questions/438878
    msg=$("${command_to_list_zip_entries[@]}" -t "$zip_file" 2>&1) || {
      # NOTE:
      # if list emtpy zip file by zipinfo/unzip command,
      # exit code is 1, and print 'Empty zipfile.'
      if [ "$msg" != 'Empty zipfile.' ]; then
        clearResponsiveMessage
        redPrint "fail to list zip entries of $zip_file, ignored: $msg" >&2
      fi
      return
    }
  fi

  "${command_to_list_zip_entries[@]}" "$zip_file" || {
    clearResponsiveMessage
    redPrint "fail to list zip entries of $zip_file, ignored!" >&2
  }
}

################################################################################
# find logic
################################################################################

searchJarFiles() {
  printResponsiveMessage "searching jars under dir ${dirs[*]} , ..."

  local jar_files total_jar_count

  jar_files=$(find "${dirs[@]}" "${find_iname_options[@]}" -type f)
  [ -n "$jar_files" ] || die "${extensions[*]} file NOT found!"

  total_jar_count=$(printf '%s\n' "$jar_files" | wc -l)
  # remove white space, because the `wc -l` output on mac contains white space!
  total_jar_count=${total_jar_count//[[:space:]]/}

  echo "$total_jar_count"
  printf '%s\n' "$jar_files"
}

readonly JAR_COLOR='\e[1;35m' SEP_COLOR='\e[1;32m'
__outputResultOfJarFile() {
  local jar_file=$1 file
  # shellcheck disable=SC2206
  local grep_opt_args=("$regex_mode" ${ignore_case_option:-} ${grep_color_option:-} -- "$pattern")

  if $only_print_file_name; then
    local matched=false
    # NOTE: Do NOT use -q flag with grep:
    #   With the -q flag the grep program will stop immediately when the first line of data matches.
    #   Normally you shouldn't use -q in a pipeline like this
    #   unless you are sure the program at the other end can handle SIGPIPE.
    # more info see:
    # - https://stackoverflow.com/questions/19120263/why-exit-code-141-with-grep-q
    # - https://unix.stackexchange.com/questions/305547/broken-pipe-when-grepping-output-but-only-with-i-flag
    # - http://www.pixelbeat.org/programming/sigpipe_handling.html
    grep -c "${grep_opt_args[@]}" &>/dev/null && matched=true

    [ "$print_matched_files" != "$matched" ] && return

    clearResponsiveMessage
    if [ -t 1 ]; then
      printf "$JAR_COLOR%s$COLOR_RESET\n" "$jar_file"
    else
      printf '%s\n' "$jar_file"
    fi
  else
    {
      # Prevent grep from exiting in case of no match
      # https://unix.stackexchange.com/questions/330660
      grep "${grep_opt_args[@]}" || true
    } | while IFS= read -r file; do
      clearResponsiveMessage
      if [ -t 1 ]; then
        printf "$JAR_COLOR%s$SEP_COLOR%s$COLOR_RESET%s\n" "$jar_file" "$separator" "$file"
      else
        printf '%s\n' "$jar_file$separator$file"
      fi
    done
  fi
}

findInJarFiles() {
  [ -t 1 ] && local -r grep_color_option='--color=always'
  local counter=1 total_jar_count jar_file

  read -r total_jar_count
  while IFS= read -r jar_file; do
    printResponsiveMessage "finding in jar($((counter++))/$total_jar_count): $jar_file"
    listZipEntries "$jar_file" | __outputResultOfJarFile "$jar_file"
  done

  clearResponsiveMessage
}

searchJarFiles | findInJarFiles