user-tools/foreach

   1 #!/bin/bash
   2
   3 true <<'EOF'
   4 =pod
   5
   6 =head1 NAME
   7
   8 foreach - Run an OS or shell command on each input line, similar to xargs(1)
   9
  10 =head1 SYNOPSIS
  11
  12 foreach [I<OPTIONS>] I<COMMAND> [I<ARGS> ...]
  13
  14 =head1 DESCRIPTION
  15
  16 Take each input line from stdin as B<DATA>, and run I<COMMAND> with B<DATA> appended to the end of I<ARGS> as a single argument.
  17
  18 If C<{}> is there in I<ARGS> then it's substituted with B<DATA> rather than append to the end,
  19 unless I<--no-placeholder> is given, because then C<{}> is read literally.
  20 Additionally, parse B<DATA> into fields and add each of them to the end of I<ARGS> if I<--fields> is given.
  21 Numbered placeholders, like C<{0}>, C<{1}>, ... are substituted with the respective field's value.
  22
  23 So if you have not specified any I<ARGS> in the command line and type both I<--data> and I<--fields>,
  24 then B<DATA> goes into argv[1], and the first field goes into argv[2], second to argv[3] and so on.
  25 If have not given I<--data> nor I<--fields>, then I<--data> is implied.
  26
  27 If called with I<--sh> option, I<COMMAND> is run within a shell context;
  28 input line goes to C<$DATA>, individual fields go to C<${FIELD[@]}> (0-indexed).
  29
  30 Both in command and shell (--sh) modes, individual fields are available in
  31 C<$F0>, C<$F1>, ... environment variables.
  32
  33 Set I<-d> B<DELIM> if you want to split B<DATA> not by C<$IFS> but by other delimiter chars,
  34 eg. C<-d ",:"> for command and colon.
  35 There is also C<-t>/C<--tab> option to set delimiter to TAB for your convenience.
  36
  37 =head1 OPTIONS
  38
  39 =over 4
  40
  41 =item -e, --sh
  42
  43 I<COMMAND> is a shell script and for each B<DATA>, it runs in the same shell context,
  44 so variables are preserved across invocations.
  45
  46 =item -l, --data
  47
  48 Pass B<DATA> in the arguments after the user-specified I<ARGS>.
  49
  50 =item -f, --fields
  51
  52 Pass individual fields of B<DATA> in the arguments after B<DATA> if I<--data> is given,
  53 or after the user-specified I<ARGS> if I<--data> is not given.
  54
  55 =item -d, --delimiter DELIM
  56
  57 Cut up B<DATA> into fields at B<DELIM> chars.
  58 Default is C<$IFS>.
  59
  60 =item -t, --tab
  61
  62 Cut up B<DATA> into fields at TAB chars..
  63
  64 =item -P, --no-placeholder
  65
  66 Do not substitute C<{}> with B<DATA>.
  67
  68 =item -p, --prefix I<TEMPLATE>
  69
  70 Print something before each command execution.
  71 I<TEMPLATE> is a bash-interpolated string,
  72 may contain C<$DATA> and C<${FIELD[n]}>.
  73 Probably need to put in single quotes when passing to foreach(1) in the invoking shell.
  74 Beware using backtick, command substitution, double quotes, semicolon - since it's B<eval>ed.
  75
  76 =item -v, --verbose
  77
  78 =item -n, --dry-run
  79
  80 =item -E, --errexit
  81
  82 Stop executing if a I<COMMAND> returns non-zero.
  83 Rather exit with the said command's exit status code.
  84
  85 =back
  86
  87 =head1 EXAMPLES
  88
  89  ls -l --time-style +%FT%T%z | foreach --data --fields sh -c 'echo size: $5, file: $7'
  90  ls -l --time-style +%FT%T%z | foreach --sh 'echo size: ${FIELD[4]}, file: ${FIELD[6]}'
  91
  92 =head1 LIMITS
  93
  94 Placeholders for field values (C<{0}>, C<{1}>, ...) are considered from 0 up to 99.
  95 There must be a limit somewhere, otherwise I had to write a more complex replace routine.
  96
  97 =head1 CAVEATS
  98
  99 Placeholder C<{}> is substituted in all I<ARGS> anywhere, not just stand-alone C<{}> arguments,
 100 but IS NOT ESCAPED!
 101 So be careful using it in shell command arguments like C<sh -e 'echo "data is: {}"'>.
 102
 103 =head1 SEE ALSO
 104
 105 xargs(1), xe(1), apply(1), xapply(1) L<https://www.databits.net/~ksb/msrc/local/bin/xapply/xapply.html>
 106
 107 =cut
 108
 109 EOF
 110
 111
 112 # syntax highlighter correction: '
 113
 114
 115
 116 FOREACH_MODE=command
 117 FOREACH_VERBOSE=no
 118 unset FOREACH_DELIM
 119 FOREACH_PASS_DATA=maybe
 120 FOREACH_PASS_FIELDS=no
 121 FOREACH_REPLACE_PLACEHOLDER=yes
 122 FOREACH_DRYRUN=no
 123 FOREACH_ERREXIT=no
 124 FOREACH_PREFIX_TEMPLATE=''
 125
 126
 127 while [ $# != 0 ]
 128 do
 129         case "$1" in
 130         --help)
 131                 pod2text "$0"
 132                 exit
 133                 ;;
 134         -e|--sh)
 135                 FOREACH_MODE=sh
 136                 ;;
 137         -l|--data)
 138                 FOREACH_PASS_DATA=yes
 139                 ;;
 140         -f|--fields)
 141                 FOREACH_PASS_FIELDS=yes
 142                 ;;
 143         -d|--delimiter)
 144                 shift
 145                 FOREACH_DELIM=$1
 146                 ;;
 147         -t|--tab)
 148                 FOREACH_DELIM=$'\t'
 149                 ;;
 150         -P|--no-placeholder)
 151                 FOREACH_REPLACE_PLACEHOLDER=no
 152                 ;;
 153         -p|--prefix)
 154                 shift
 155                 FOREACH_PREFIX_TEMPLATE=$1
 156                 ;;
 157         -v|--verbose)
 158                 FOREACH_VERBOSE=yes
 159                 ;;
 160         -n|--dry-run)
 161                 FOREACH_DRYRUN=yes
 162                 ;;
 163         -E|--errexit)
 164                 FOREACH_ERREXIT=yes
 165                 ;;
 166         --)
 167                 shift
 168                 break;;
 169         -*)
 170                 echo "foreach: unknown option: $1" >&2
 171                 exit -1
 172                 ;;
 173         *)      break;;
 174         esac
 175         shift
 176 done
 177
 178 if [ $# = 0 ]
 179 then
 180         pod2text "$0" >&2
 181         exit -1
 182 fi
 183
 184 if [ $FOREACH_PASS_FIELDS = yes -a $FOREACH_PASS_DATA != yes ]
 185 then
 186         FOREACH_PASS_DATA=no
 187 fi
 188 if [ $FOREACH_PASS_FIELDS != yes ]
 189 then
 190         FOREACH_PASS_DATA=yes
 191 fi
 192
 193 declare -a FOREACH_COMMAND=("$@")
 194
 195 while read -r DATA
 196 do
 197         export DATA
 198         declare -a FIELD=()
 199         IFS=${FOREACH_DELIM+$FOREACH_DELIM}${FOREACH_DELIM-$IFS} read -r -a FIELD <<< "$DATA"
 200
 201         for ((idx = 0; idx < ${#FIELD[@]}; idx++))
 202         do
 203                 export F$idx="${FIELD[$idx]}"
 204         done
 205         # unset old F$idx variables
 206         while declare -p F$idx >/dev/null 2>/dev/null
 207         do
 208                 unset F$idx
 209                 let idx++
 210         done
 211
 212         FOREACH_COMMAND_STATUS=0
 213
 214         declare -a cmd_and_args=()
 215         placeholder_found=no
 216         if [ "$FOREACH_REPLACE_PLACEHOLDER" = yes ]
 217         then
 218                 for arg in "${FOREACH_COMMAND[@]}"
 219                 do
 220                         if [[ $arg =~ \{\} ]]
 221                         then
 222                                 placeholder='{}'
 223                                 arg=${arg//$placeholder/$DATA}
 224                                 placeholder_found=yes
 225                         fi
 226                         for ((idx = 0; idx < 100; idx++))
 227                         do
 228                                 if [[ $arg =~ \{$idx\} ]]
 229                                 then
 230                                         placeholder="{$idx}"
 231                                         arg=${arg//$placeholder/${FIELD[$idx]}}
 232                                         placeholder_found=yes
 233                                 fi
 234                         done
 235                         cmd_and_args+=("$arg")
 236                 done
 237         else
 238                 cmd_and_args=("${FOREACH_COMMAND[@]}")
 239         fi
 240
 241         if [ "$FOREACH_MODE" = command ]
 242         then
 243                 if [ "$FOREACH_REPLACE_PLACEHOLDER" != yes -o $placeholder_found = no ]
 244                 then
 245                         if [ "$FOREACH_PASS_DATA" = yes ]; then cmd_and_args+=("$DATA"); fi
 246                         if [ "$FOREACH_PASS_FIELDS" = yes ]; then cmd_and_args+=("${FIELD[@]}"); fi
 247                 fi
 248         fi
 249
 250         if [ "$FOREACH_VERBOSE" = yes ]
 251         then
 252                 echo "foreach: ${cmd_and_args[*]}" >&2
 253         fi
 254
 255         eval "FOREACH_PREFIX=\"$FOREACH_PREFIX_TEMPLATE\""
 256         echo -n "$FOREACH_PREFIX"
 257
 258         if [ "$FOREACH_DRYRUN" = no ]
 259         then
 260                 if [ "$FOREACH_MODE" = command ]
 261                 then
 262                         command "${cmd_and_args[@]}"
 263                         FOREACH_COMMAND_STATUS=$?
 264                 else
 265                         eval "${cmd_and_args[@]}"
 266                         FOREACH_COMMAND_STATUS=$?
 267                 fi
 268         fi
 269
 270         if [ $FOREACH_ERREXIT = yes -a $FOREACH_COMMAND_STATUS != 0 ]
 271         then
 272                 exit $status
 273         fi
 274 done