How to use an environment variable inside a quoted string in Bash

Just a quick note/summary for any who came here via Google looking for the answer to the general question asked in the title (as I was). Any of the following should work for getting access to shell variables inside quotes:

echo "$VARIABLE"
echo "${VARIABLE}"

Use of single quotes is the main issue. According to the Bash Reference Manual:

Enclosing characters in single quotes (') preserves the literal value of each character within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash. [...] Enclosing characters in double quotes (") preserves the literal value of all characters within the quotes, with the exception of $, `, \, and, when history expansion is enabled, !. The characters $ and ` retain their special meaning within double quotes (see Shell Expansions). The backslash retains its special meaning only when followed by one of the following characters: $, `, ", \, or newline. Within double quotes, backslashes that are followed by one of these characters are removed. Backslashes preceding characters without a special meaning are left unmodified. A double quote may be quoted within double quotes by preceding it with a backslash. If enabled, history expansion will be performed unless an ! appearing in double quotes is escaped using a backslash. The backslash preceding the ! is not removed. The special parameters * and @ have special meaning when in double quotes (see Shell Parameter Expansion).

In the specific case asked in the question, $COLUMNS is a special variable which has nonstandard properties (see lhunath's answer above).

Note that COLUMNS is:

1. NOT an environment variable. It is an ordinary bash parameter that is set by bash itself.
2. Set automatically upon receipt of a SIGWINCH signal.

That second point usually means that your COLUMNS variable will only be set in your interactive shell, not in a bash script.

If your script's stdin is connected to your terminal you can manually look up the width of your terminal by asking your terminal:

tput cols

And to use this in your SVN command:

svn diff "$@" --diff-cmd /usr/bin/diff -x "-y -w -p -W $(tput cols)"

(Note: you should quote "$@" and stay away from eval ;-))

Another approach towards keeping single quotes itself in that case you can just wrap around your variable in single quote instead of how you would usually do with double quotes

X='abc'
>echo 'preceeding text ---"${X}"---- succeesing text'
preceeding text ---"${X}"---- succeesing text
>echo 'preceeding text ---"$X"---- succeesing text'
preceeding text ---"$X"---- succeesing text
>echo 'preceeding text ---'$X'---- succeesing text'
preceeding text ---abc---- succeesing text
>echo 'preceeding text ---'${X}'---- succeesing text'
preceeding text ---abc---- succeesing text

1 - Make sure the variable is correctly set.

COLUMNS=60  #example, no '$' here and no spaces!!
# or...
COLUMNS=`something that prints a number`

2- In shell script, 'single quote kills $dollar variables' but "double quotes keep $dollar $variables"

variable="Hello"
# You should not use inside apostrophes:
echo 'bla $variable'     # <-- single quote kills $variable
# Output:  'bla $variable'

# But 
echo "bla $variable"     # <-- double quoted!
# Produces: "bla Hello"

The following script works for me for multiple values of $COLUMNS. I wonder if you are not setting COLUMNS prior to this call?

#!/bin/bash
COLUMNS=30
svn diff $@ --diff-cmd /usr/bin/diff -x "-y -w -p -W $COLUMNS"

Can you echo $COLUMNS inside your script to see if it set correctly?

You are doing it right, so I guess something else is at fault (not export-ing COLUMNS ?).

A trick to debug these cases is to make a specialized command (a closure for programming language guys). Create a shell script named diff-columns doing:

exec /usr/bin/diff -x -y -w -p -W "$COLUMNS" "$@"

and just use

svn diff "$@" --diff-cmd  diff-columns

This way your code is cleaner to read and more modular (top-down approach), and you can test the diff-columns code thouroughly separately (bottom-up approach).