bash functions with loops and pipes - bash

Question

I have a bash script that pipes the contents of a file into a series of user defined functions each of which performs a sed operation on stdin, sending output to stdout.
For example:
#!/bin/bash
MOD_config ()
{
sed 's/config/XYZ/g'
}
MOD_ABC ()
{
sed 's/ABC/WHOA!/g'
}
cat demo.txt \
| MOD_config \
| MOD_ABC
So far so good. Everything is working great.
Now I want to allow additional pairs of pattern changes specified via the script's command line. For example, I'd like to allow the user to run any of these:
demo.sh # changes per script (MOD_config and MOD_ABC)
demo.sh CDE 345 # change all 'CDE' to '345'
demo.sh CDE 345 AAAAA abababa # .. also changes 'AAAAA' to 'abababa'
so I tried adding this to the script:
USER_MODS ()
{
if [ $# -lt 1]; then
#just echo stdin to stdout if no cmd line args exist
grep .
else
STARTING_ARGC=$#
I=1
while [ $I -lt $STARTING_ARGC ]; then
sed "s/$1/$2/g"
shift
shift
I=`expr $I + 2`
done
fi
}
cat demo.txt \
| MOD_config \
| MOD_ABC \
| USER_MODS
This approach works only if I have no command line args, or if I have only two. However, adding additional args on the command line has no effect.
Not sure exactly how to send stdout of one iteration of the while loop to the stdin of the next iteration. I think that's the crux of my problem.
Is there a fix for this? Or should I take a different approach altogether?

Answer 1

To have a dynamic list of pipes, you'll want a recursive solution. Have a function which applies one set of modifications and then calls itself with two fewer arguments. If the function has no arguments then simply call cat to copy stdin to stdout unchanged.
mod() {
if (($# >= 2)); then
search=$1
replace=$2
shift 2
sed "s/$search/$replace/g" | mod "$#"
else
cat
fi
}
# Apply two base modifications, plus any additional user mods ("$#")
mod config XYZ ABC 'WHOA!' "$#"

Answer 2

A remark: with more than 2 arguments, your seds are executed, but after the first one that has already consumed all the input. Instead you want to build up a chain of sed commands.
#!/bin/bash
mod_config() { sed 's/config/XYZ/g'; }
mod_abc() { sed 's/ABC/WHOA!/g'; }
user_mods() {
local IFS=';'
local sed_subs=()
while (($#>=2)); do
sed_subs+=( "s/$1/$2/g" )
shift 2
done
# at this point you have an array of sed s commands (maybe empty!).
# Just join then with a semi colon using the IFS already set
sed "${sed_subs[*]}"
}
cat demo.txt \
| mod_config \
| mod_abc \
| user_mods "$#" # <--- don't forget to pass the arguments to your function
And pray that your users aren't going to input stuff that will confuse sed, e.g., a slash!
(And sorry, I lowercased all your variables. Uppercases are sooooo ugly).

Answer 3

Try this, uses recursive call to go down the list of replacement pairs calling USER_MODS each time.
#!/bin/bash
MOD_config ()
{
sed 's/config/XYZ/g'
}
MOD_ABC ()
{
sed 's/ABC/WHOA!/g'
}
USER_MODS ()
{
if [ $# -lt 1 ]; then
#just echo stdin to stdout if no args exist
grep .
else
# grap the next two arguments
arg1=$1
arg2=$2
# remove them from the argument list
shift
shift
# do the replacement for these two and recursivly pipe to the function with
# the new argument list
sed "s/$arg1/$arg2/g" | USER_MODS $#
fi
}
cat demo.txt \
| MOD_config \
| MOD_ABC \
| USER_MODS $#