making bash script pretty and neat

Question

I have done something in bash, the script takes up three file names and processes them and stores the final result in third file.

The script is:

#!/bin/bash

#clear

echo -n " Bam File "
read BamFile

echo -n " Region File "
read BedFile

echo -n " Output File "
read OutFile

awk '{print $1 "\t" $2 "\t" $3 "\t" $3-$2}' < $BedFile >Temp

coverageBed -abam $BamFile -b $BedFile -counts > bases

awk '{print $4 }' <bases >tempbases

paste -d "\t" Temp tempbases >TtTemp

samtools view -c -F 260 $BamFile > totalNumReads

cat totalNumReads | awk '{print $1}'>tags

tag=`cat tags`
echo " Number of tags present in file = $tag"

awk '{print $1 "\t" $2 "\t" $3 "\t" $4 "\t" $5 "\t" $5/($4/1000* "'$tag'"/1000000) } '<TtTemp > $OutFile

This script works well.

However, I would like to make the following adjustment to the script.

Instead of asking file names one by one,, I would like to provide them at the start

something like this:

process.bash -bam BamFile.bam -region RegFile -Out OutFile

where process.bash is my script and the three files are provided right at the start.

Could anyone please help me in doing this.

Thank you

Answer 1

You can test for the arguments like that:

#!/bin/bash

bam=null
reg=null
out=null

while [[ $# -gt 1 ]]; do
    arg="$1"
    case $arg in
        --bam)
            bam=$2
            shift
        ;;
        --reg)
            reg=$2
            shift
        ;;
        --out)
            out=$2
            shift
        ;;
        --help)
            helpmenu
        ;;
        *)
            shift
        ;;
    esac
    shift
done

function helpmenu() {
    echo -e "Your help text\n"
    exit 0
}

# Continue your script with the variables bam, reg and out
# ...

---

Then you can use your script like

$ process.bash --bam BamFile.bam --reg RegFile --out OutFile

That's it pretty much.

You can make stuff like help menus by using functions. For instance, I call the function helpmenu which is defined below. Then it just exists the script after echoing.

EDIT:

Since there has been a long discussion in the comments under this post let me make some stuff clear:

In my opinion, handling the arguments per hand like I did in my post is much more robust. The reason for that is, it supports a wide range of un*x systems (e.g. Non-POSIX Systems).

Then, because it was stated only long commands are supported: Short commands are supported as well. I just didn't add them to the code because it wasn't asked by the OP. For instance, if you want to be able to pass files like -b file as well as --bam file you just have to change the case statement accordingly:

-b|--bam)
    bam=$2
    shift
;;

I don't see anything wrong with this answer, as it provides the functionality asked. I go by this method myself in all of my scripts and never had problems doing so.

Answer 2

Although looping over the arguments is also a good solution I'd like to provide a solution using the getopts command.

I use the internal getopts, not an extension, which has several limitations (i.e. you can only use single characters to refer to arguments).

Next I provide the most similar solution that I have found out.

#!/bin/bash

  ##############################
  # HELPER METHODS
  ##############################

  # Parses the script arguments
  getArgs() {
    # Parse Options
    while getopts :hvb:r:o:-: flag; do
      # Treat the argument
      case "$flag" in
        h)
          # Display help
          usage
          ;;
        v)
          # Display version
          show_version
          ;;
        b)
          bamFile=${OPTARG}
          ;;
        r)
          regFile=${OPTARG}
          ;;
        o)
          outFile=${OPTARG}
          ;;
        -)
          # Check more complex arguments of the form --OPT, --OPT=VALUE
          case "$OPTARG" in
            help)
              # Display help
              usage
              ;;
            version)
              show_version
              ;;
            bam=*)
              # Get bam filename
              bamFile=$(echo $OPTARG | sed -e 's/bam=//g')
              ;;
            reg=*)
              # Get bam filename
              regFile=$(echo $OPTARG | sed -e 's/reg=//g')
              ;;
            out=*)
              # Get bam filename
              outFile=$(echo $OPTARG | sed -e 's/out=//g')
              ;;
            *)
              # Flag didn't match any patern. Raise exception
              display_error "${OPTARG}"
              ;;
          esac
          ;;
        *)
          # Flag didn't match any patern. Raise exception
          display_error "${OPTARG}"
          ;;
      esac
    done
  }

  usage() {
    echo "Usage: "
    exit 0
  }

  show_version() {
    echo "Version: "
    exit 0
  }

  display_error() {
    local argument=$1
    echo "[ERROR] Bad argument $argument"
    exit 1
  }

  ##############################
  # MAIN PROCESS
  ##############################
  getArgs "$@"

  echo "[DEBUG] BAM $bamFile"
  echo "[DEBUG] REG $regFile"
  echo "[DEBUG] OUT $outFile"

  awk '{ print $1 "\t" $2 "\t" $3 "\t" $3-$2 }' < $bedFile > Temp
  coverageBed -abam $bamFile -b $bedFile -counts > bases

  awk '{print $4 }' < bases > tempbases
  paste -d "\t" Temp tempbases > TtTemp
  samtools view -c -F 260 $bamFile > totalNumReads

  cat totalNumReads | awk '{ print $1 }' > tags
  tag=$(cat tags)
  echo " Number of tags present in file = $tag"
  awk '{ print $1 "\t" $2 "\t" $3 "\t" $4 "\t" $5 "\t" $5/($4/1000* "'$tag'"/1000000) }' < TtTemp > $outFile

Some sample outputs:

$./process.sh -v
Version: 
$./process.sh --version
Version: 
$./process.sh -h
Usage: 
$./process.sh --help
Usage: 
$./process.sh -b bamfile -r regfile -o outfile
[DEBUG] BAM bamfile
[DEBUG] REG regfile
[DEBUG] OUT outfile
$./process.sh --bam=bamfile -rregfile --out=outfile
[DEBUG] BAM bamfile
[DEBUG] REG regfile
[DEBUG] OUT outfile

As I said, there are some limitations. For example:

$./process.sh --bam=bamfile -rregfile -out=outfile
[DEBUG] BAM bamfile
[DEBUG] REG regfile
[DEBUG] OUT ut=outfile

Is a valid entry although the user was trying to specify another thing. From my point of view, you should check the bamFile, regFile, outFile values after the parsing and before beginning the process.