Can't indent heredoc to match code block's indentation

If there’s a “First World Problems” for scripting, this would be it.

I have the following code in a script I’m updating:

if [ $diffLines -eq 1 ]; then
        dateLastChanged=$(stat --format '%y' /.bbdata | awk '{print $1" "$2}' | sed 's/.[0-9]*//g')

        mailx -r "Systems and Operations <sysadmin@[redacted].edu>" -s "Warning Stale BB Data" jadavis6@[redacted].edu <<EOI
        Last Change: $dateLastChanged

        This is an automated warning of stale data for the UNC-G Blackboard Snapshot process.
EOI

else
        echo "$diffLines have changed"
fi

The script sends email without issues, but the mailx command is nested within an if statement so I appear to be left with two choices:

  1. Put EOI on a new line and break indentation patterns or
  2. Keep with indentation but use something like an echo statement to get mailx to suck up my email.

I’m open to alternatives to heredoc, but if there’s a way to get around this it’s my preferred syntax.

Asked By: Bratchley

||

You can change the here-doc operator to <<-
You can then indent both the here-doc and the delimiter with tabs:

#! /bin/bash
cat <<-EOF
    indented
    EOF
echo Done

Note that you must use tabs, not spaces, to indent both the here-doc and the delimiter. This means the above example won’t work copied (Stack Exchange replaces tabs with spaces). If you put any quotes around the first EOF delimiter, then parameter expansion, command substitution, and arithmetic expansion will not be in effect.

Answered By: choroba

The other method would be herestrings:

    mail_content="Last Change: $dateLastChanged

    This is an automated warning of stale data for the UNC-G Blackboard Snapshot process."
    mailx -r "Systems and Operations <sysadmin@[redacted].edu>" -s "Warning Stale BB Data" jadavis6@[redacted].edu <<<"$mail_content"
Answered By: muru

Hmm… Seems like you could take better advantage of the --format argument here to use --printf instead and just pass the lot over a pipe. Also, your if...fi is a compound command – it can take a redirect which all contained commands will inherit, so maybe you don’t need to nest the heredoc at all.

if      [ "$diffLines" = 1 ]
then    stat --printf "Last Change: %.19ynn$(cat)n" /.bbdata |
        mailx   -r  "Systems and Operations <sysadmin@[redacted].edu>" 
                -s  "Warning Stale BB Data" 'jadavis6@[redacted].edu'
else    echo    "$diffLines have changed"
fi      <<STALE
This is an automated warning of stale data for the UNC-G Blackboard Snapshot process.
STALE
Answered By: mikeserv

Try this:

sed 's/^ *//' >> ~/Desktop/text.txt << EOF
    Load time-out reached and nothing to resume.
    $(date +%T) - Transmission-daemon exiting.
EOF
Answered By: robz

If you don’t need command substitution and parameter expansion inside your here-document, you can avoid using tabs by adding the leading spaces to the delimiter:

$     cat << '    EOF'
>         indented
>     EOF
        indented
$     cat << '    EOF' | sed -r 's/^ {8}//'
>         unindented
>     EOF
unindented

I couldn’t figure out a way to use this trick and keep parameter expansion, though.

Answered By: itsadok

This answer is GNU-Bash-specific.

The trick is that we use the <<< one-word here-doc offered by Bash, and we make that a multi-line item.

We also avoid a UUoC: we don’t need a cat process to feed input to sed:

$ sed '1d;s/^    //' <<<"
    {
       TERM=$TERM
    }
    bye"

Output shows leading four-space indentation removed, and $TERM expanded:

{
   TERM=xterm-256color
}
bye

the 1d command in sed is to delete the first blank line, which exists because our quoted literal starts with a newline after the opening quote.

Of course, in the real script for which this is indented—pardon me, intendeded—we would line up the braces with the sed command, which would be indented inside a loop or conditional.

If we start each line of the datum with a delimiter, then a simple sed substitution will delete a variable amount of indentation, so that the block can be freely moved around between indentation levels:

while command ; do
    if condition ; then
        variable=$(sed '1d;s/^.*|//' <<<"
                  |{
                  |   TERM=$TERM
                  |}
                  |bye
                  ")
    fi
done

One last idea is to put the indent magic into a variable which is used as a sort of macro:

# put in some common definitions library section
indent='sed 1d;s/^.*|//'

# ...

while command ; do
    if condition ; then
        variable=$($indent <<<"
                  |{
                  |   TERM=$TERM
                  |}
                  |bye
                  ")
    fi
done

We can improve this by writing a good old-fashioned function:

# put in some common definitions library section
ind()
{
   sed '1d;s/^.*|//' <<<$1
}

# ...

while command ; do
    if condition ; then
        variable=$(ind "
                  |{
                  |   TERM=$TERM
                  |}
                  |bye
                  ")
    fi
done

Then we have abstracted away the <<< entirely.

Answered By: Kaz

Given that this is an aesthetic issue, here’s an aesthetic solution: place some visual aid into the code which acts as a transition between the "proper" pre-heredoc indentation and temporary left-alignment of the heredoc block.

if [ $condition -eq 1 ]; then
              ︙
       some code
       some more code

# ____/

mailx -r "Systems and Operations <sysadmin@[redacted].edu>" -s "Warning Stale BB Data" jadavis6@[redacted].edu <<EOI
Last Change: $dateLastChanged

This is an automated warning of stale data for the UNC-G Blackboard Snapshot process.
EOI

# ____
#     

       even more code
              ︙
else
        code
          ︙
fi

I find that this allows my brain to better perceive the left-aligned code
as part of the indented code around it. When I’m writing in a code editor that indicates the level of indentation with a vertical line, the above visual aid appears to merge into the indicator for the previous indent level, making the transition feel even more intuitive.
Not everyone will find this satisfying, of course,
but there don’t seem to be any universally satisfying answers
for when you have space-indented code.

Answered By: Krister Janmore

You could use a here-string (<<<) instead of a here-document (<<MARKER), which at least avoids the end-of-document marker not being intended.

if [[ true ]]; then
  # Sample indented block
  cat <<<'First line
  Second line
  '
fi

Output (note the trailing empty line):

First line
  Second line
  

You can combine this with other commands to strip indent. Here cut will output the fifth character onwards of each line. -c is character mode, and 5- is the range of characters to output.

if [[ true ]]; then
  # Sample indented block
  cut -c5- <<<'
    First line
    Second line
  '
fi

Output (note first and last line are empty):


First line
Second line

Excellent explanation of the difference at command line – What’s the difference between <<, <<< and < < in bash? – Ask Ubuntu.

Answered By: RobM

There’s a workaround I use to cheat the "space stripping behaviour".
It allows me to write the code with indents as I want it to be human readable too.

#!/bin/bash

T=`echo -ne ''`

TEST_CAT()
{
    cat <<- _EOF
    Line without indent
$T  This is indented first line
    $T      Line with double indent
    $T      Again a line with double indent
        $T      Another Line with double indent
            $T$T    Note: That extra '$T' removes one indent
            $T  This is again a single indent
    _EOF

}

TEST_CAT
Answered By: mdk

There have been quite many good answers to this question already. However the one thing that I would like to improve is that most answers either require the use of tabs, or they remove an arbitrary number of white spaces at the beginning of the indented code. The latter problem has even been raised as a comment by @ivan_pozdeev, but it has not been answered yet.

In my solution, I prefer variable expansion to work, so I do not quote the EOF as done by https://unix.stackexchange.com/a/436168/240734. Therefore, the ending EOF must not be indented. For me, that is an acceptable compromise. If you prefer the ending EOF to be indented too, then please see the other answers with their respective pro’s and cons.

Also, I want to be able to use spaces for indenting instead of tabs, therefore the concept of https://unix.stackexchange.com/a/76483/240734 does not work for me.

My solution is the following:

# This 'if' statement is only added to showcase the indenting:
if true ; then
    # Use perl in the heredoc to remove only the first 4 spaces or
    # the first tab character in the heredoc. Adjust this to the
    # indenting that is used in your heredoc. Instead of perl, also
    # sed or awk can be used.
    cat << EOF | perl -pe 's@^(    |t)@@g' > /some/file
    # This line is not indented in the created file.
    if true ; then
        # This line is indented by 4 spaces in the created file.
        echo "hello world"
    fi || exit 1
EOF

    # Check if there heredoc file creation / redirection worked,
    # and fail if it did not:
    if test $? -ne 0 ; then
        exit 1
    fi
fi
Answered By: emmenlau