Linux bash - reprint user's input - linux

Question

I have an old shell script which needs to be moved to bash. This script prints progress of some activity and waits for user's commands. If no action is taken by user for 15 seconds screen is redrawn with new progress and timer starts again. Here's my problem:
I am trying to use read -t 15 myVar - this way after 15 seconds of waiting loop will be restarted. There is however a scenario which brings me a problem:
screen redrawn and script waits for input (prints 'Enter command:')
user enters foo but doesn't press enter
after 15 seconds screen is again redrawn and script waits for input - note, that foo is not displayed anywhere on the screen (prints 'Enter command:')
user enters bar and presses enter
At this moment variable $myVar holds 'foobar'.
What do I need? I am looking for a way to find the first string typed by user, so I could redisplay it after refreshing status. This way user will see:
Enter command: foo
On Solaris I could use stty -pendin to save input into some sort of a buffer, and after refresh run stty pendin to get this input from buffer and print it on a screen.
Is there a Linux equivalent to stty pendin feature? Or maybe you know some bash solution to my problem?

Answer 1

I guess one way would be to manually accumulate the user input ... use read with -n1 so that it returns after every character, then you can add it to your string. To prevent excessive drawing you would have to calculate how many remaining seconds are on the 15 second clock ...
Addendum:
For your comment about space/return - you basically want to use an IFS without the characters you want, such as space
example:
XIFS="${IFS}" # backup IFS
IFS=$'\r' # use a character your user is not likely to enter (or just the same but w/o the space)
# Enter will look like en empty string
$ read -n1 X; echo --; echo -n "${X}" | od -tx1
--
0000000
# space will be presented as a character
$ read -n1 X; echo --; echo -n "${X}" | od -tx1
--
0000000 20
0000001
# after you are all done, you probably wantto restore the IFS
IFS="${XIFS}"

Answer 2

Expanding on what #nhed was saying, perhaps something like this:
#!/bin/bash
limit=5
draw_screen () {
clear;
echo "Elapsed time: $SECONDS" # simulate progress indicator
printf 'Enter command: %s' "$1"
}
increment=$limit
str=
end=0
while ! [ $end -eq 1 ] ; do
draw_screen "$str"
while [ $SECONDS -lt $limit ] && [ $end -eq 0 ] ; do
c=
IFS= read -t $limit -r -n 1 -d '' c
if [ "$c" = $'\n' ] ; then
end=1
fi
str="${str}${c}"
done
let limit+=increment
done
str="${str%$'\n'}" # strip trailing newline
echo "input was: '$str'"
The solution is not ideal:
You can sometimes be typing in the middle of the loop and mess up input
You can't edit anything nicely (but this is fixable with a lot more work)
But maybe it's enough for you.

Answer 3

If you have Bash 4:
read -p 'Enter something here: ' -r -t 15 -e -i "$myVar" myVar
The -e turns on readline support for the user's text entry. The -i uses the following text as the default contents of the input buffer which it displays to the user. The following text in this case is the previous contents of the variable you're reading into.
Demonstration:
$ myVar='this is some text' # simulate previous entry
$ read -p 'Enter something here: ' -r -t 15 -e -i "$myVar" myVar
Enter something here: this is some text[]
Where [] represents the cursor. The user will be able to backspace and correct the previous text, if needed.

Answer 4

OK, I think I have the solution. I took nhed's proposition and worked a bit on it :)
The main code prints some status and waits for input:
while :
do
# print the progress on the screen
echo -n "Enter command: "
tput sc # save the cursor position
echo -n "$tmpBuffer" # this is buffer which holds typed text (no 'ENTER' key yet)
waitForUserInput
read arguments <<< $(echo $mainBuffer) # this buffer is set when user presses 'ENTER'
mainBuffer="" # don't forget to clear it after reading
# now do the action requested in $arguments
done
Function waitForUserInput waits 10 seconds for a keypress. If nothing typed - exits, but already entered keys are saved in a buffer. If key is pressed, it is parsed (added to buffer, or removed from buffer in case of backspace). On Enter buffer is saved to another buffer, from which it is read for further processing:
function waitForUserInput {
saveIFS=$IFS # save current IFS
IFS="" # change IFS to empty string, so 'ENTER' key can be read
while :
do
read -t10 -n1 char
if (( $? == 0 ))
then
# user pressed something, so parse it
case $char in
$'\b')
# remove last char from string with sed or perl
# move cursor to saved position with 'tput rc'
echo -n "$tmpBuffer"
;;
"")
# empty string is 'ENTER'
# so copy tmpBuffer to mainBuffer
# clear tmpBuffer and return to main loop
IFS=$saveIFS
return 0
;;
*)
# any other char - add it to buffer
tmpBuffer=$tmpBuffer$char
;;
esac
else
# timeout occured, so return to main function
IFS=$saveIFS
return 1
fi
done
}
Thanks to all of you for your help!