Generic "header" and "footer", to be included unchanged in a script to achieve multiline statements

Question

To cut the chase to the point, the following (originating from a Charles Duffy's reply to a related question - see his answer) would be an acceptable format for my requirements:

eval "$(
  { sed -E -e 's/^[ ]+//;' -e ':a;N;$!ba;s/\n//g' | tr -d '\n'; } <<'____COMMAND'
sshfs 
foo_user@fooserver.com:/sftp_folder 
  /var/sshfs.sandbox/server.com 
  -o 
    user=foo_user
    ,reconnect
    ,ServerAliveInterval=15
    ,ServerAliveCountMax=3
____COMMAND
)"

Note that there is a trailing space whenever it is needed by the command I'm trying to split into multple lines:

sshfs 
foo_user@fooserver.com:/sftp_folder 
  /var/sshfs.sandbox/server.com 
  -o 

And no trailing spaces for options that have to be concatenated without an intervening blank space:

user=foo_user
,reconnect
,ServerAliveInterval=15
,ServerAliveCountMax=3

Once concatenated, the command becomes:

sshfs foo_user@fooserver.com:/sftp_folder /var/sshfs.sandbox/server.com -o user=foo_user,reconnect,ServerAliveInterval=15,ServerAliveCountMax=3

However, I am told trailing spaces are a bad idea all around (once again, refer to Charles Duffy's reply for the motivations)

Hence I am wondering. Is there a way to achieve all these three:

1. Keeping the statement all "together".
2. Not having trailing whitespace.
3. Making the "header" and "footer" fixed and copy pastable in other scripts without modifications.

I was thinking of using a trailing backslash and modifying the parsing expression:

{ sed -E -e 's/^[ ]+//;' -e ':a;N;$!ba;s/\n//g' | tr -d '\n'; }

so that the I can achieve all three mentioned above.

Answer 1

Have you considered using a multiline command with backslashes? This makes the trailing space clearly visible.

From the Bash manual :

3.1.2.1 Escape Character

A non-quoted backslash ‘\’ is the Bash escape character. It preserves the literal value of the next character that follows, with the exception of newline. If a \newline pair appears, and the backslash itself is not quoted, the \newline is treated as a line continuation (that is, it is removed from the input stream and effectively ignored).

sshfs \
foo_user@fooserver.com:/sftp_folder \
/var/sshfs.sandbox/server.com \
-o \
user=foo_user\
,reconnect\
,ServerAliveInterval=15\
,ServerAliveCountMax=3,\

The backslash/newline trick is part of the normal parsing of commands and has no other effects than ignoring newlines, so you can use quotes the way you would normally do.

Maybe a tad less clean in terms of expressing the command itself, but does not require a here document or an additional call to sed.

This being said, CharlesDuffy recommended an array-based solution in an answer to your original question, and putting commands and arguments in an array is, in my experience, a simple and effective solution to many headaches. Is there a reason you do not want to use this method?

Answer 2

Hopefully, this will do what you want.

First, define a function intended to parse a command received on standard input.

#!/bin/bash

execute_command()
{
  local -a command=()
  local arg=
  while IFS= read -r line
  do
    [[ $line =~ [[:blank:]]*(.*[^[:blank:]\\])(\\?)[[:blank:]]*$ ]]
    if
      [[ ${BASH_REMATCH[2]} ]]
    then
      arg+=${BASH_REMATCH[1]}
    else
      command+=("$arg${BASH_REMATCH[1]}")
      arg=
    fi
  done
  "${command[@]}"
}

Then, call this function by leaving a trailing slash at the end of each line where you want the following line to be considered part of the same argument. The above code will not perform any parsing, so you cannot put two arguments on the same line (which, in your example, you are not doing, and I therefore assume is an acceptable limitation for you).

execute_command <<'____COMMAND'
sshfs
foo_user@fooserver.com:/sftp_folder
  /var/sshfs.sandbox/server.com
  -o
    user=foo_user\
    ,reconnect\
    ,ServerAliveInterval=15\
    ,ServerAliveCountMax=3
____COMMAND

This provides you with a very simple, reusable "header", does not require (but tolerates) trailing spaces and allows leading spaces on all lines, while introducing as little heavy/weird syntax as possible.