What is the simplest way to write a bash script to accept arguments and input from all possible direction (similar to sort -k1 -r)? - bash

Question

I want to write a bash script that can handle arguments and input similar to many built-in bash command. For example, like sort, it can handle
sort -k 1 -r input.txt
sort input.txt -k 1 -r
cat input.txt | sort -k 1 -r
sort -k 1 -r < input.txt
sort -k 1 -r <(cat input.txt)
I want my script to be able to handle arguments and input in the similar way
myscript.sh -i 3 -b 4 input.txt
myscript.sh input.txt -i 3 -b 4
cat input.txt | myscript.sh -i 3 -b 4
myscript.sh -i 3 -b 4 < input.txt
myscript.sh -i 3 -b 4 <(cat input.txt)
so far I only used some features from "read" and "getopts" and think that it's may be buggy if I try to do that on my own.
To make me state my question more clearly, let the content of input.text be
aaa
bbb
ccc
and I want to use value from argument i and b to do something but I'll just print it out in this example. The sample output that I want is
i : 3
b : 4
aaa
bbb
ccc
What is the best way to write a code to handle my above sample commands to give out this output?
Below is the code that got from the sandwich idea of #chepner, which is the best one so far.
#!/bin/bash -l
die () {
echo >&2 "[exception] $#"
exit 1
}
#parse param
while getopts "i:b:" OPTION; do
case "$OPTION" in
i)
i="$OPTARG"
;;
b)
b="$OPTARG"
;;
*)
die "unrecognized option"
;;
esac
done
if [ -e tmpfile ]
then
rm tmpfile
fi
shift $(($OPTIND - 1))
echo "i : "$i
echo "b : "$b
cat $1 > tmpfile
if read -t 0; then
cat >> tmpfile
fi
cat tmpfile

Answer 1

Executive summary: you can use read -t 0 to test if there is any input available on standard input. It will exit with status 0 data is immediately available on standard input (via a pipe or a redirected file), and 1 if not (e.g., still connected to the keyboard). You can then branch in your script based on whether or not you need to read from standard input.
if read -t 0; then
# Do one thing
else
# Do something else
fi
The tricky part for me was writing the script so that it does not block reading standard input if you don't pipe anything to it.
This seems to work; improvements welcome. First, consume everything on standard input; then process files given as arguments.
# The first call to read only succeeds when there is input
# available on standard input. It does not actually consume
# a line, though.
if read -t 0; then
# Read standard input normally
while read line; do
echo $line
done
fi
# I'll assume you populate an array called input files
# while processing your arguments
for file in "${inputfiles[#]"; do
cat $file
done
Here's a pointless wrapper around sort just do demonstrate another way of combining standard input with other input files:
if read -t 0; then
cat | sort fileA fileB
else
sort fileA file B
fi
A slightly more useful command might be sandwich, which outputs its standard input (if any) between two files given on the command line.
#!/bin/bash
cat "$1" # Output the first file
read -t 0 && cat # Pass through the standard input, if there is any
cat "$2" # Output the second file
# cat "$1" - "$2" is almost the same, but requires standard input.
Some calls to sandwich could be
$ sandwich header.txt footer.txt
$ sandwich header.txt footer.txt < body.txt
$ cat chapter1.txt chapter2.txt | sandwich <(echo "My header") <(echo "My footer")
This doesn't quite work, so there's room for improvement...
$ cat - | sandwich header.txt footer.txt

Answer 2

cat input.txt | command
command < input.txt
command <(cat input.txt)
These three are identical from the applications viewpoint, the shell does the redirect. The application only has to read stdin.
command input.txt
cat input.txt | command
These differ only in the file you process, in the first one it's input.txt, in the second one it's stdin, for which you can use -, most of the unix commands support it.
# echo "X" | cat -
X
So you set the default: filename=-, and if you read the filename option, you overwrite this variable.