Scripting GNU in the 21st Century

Most people tend to encounter shell scripts as attempts to write portable utilities that run properly on most, if not all, UNIX workalikes. Instead of making the best use of the shell and related programs, these scripts restrict themselves to the absolute most portable baseline of features. The extreme example of this sort of programming can be seen when one looks at the configure scripts generated by the autoconf program.

But this is 2004, and the full GNU environment is now commonplace. The advanced shells and utilities now are the default user environment for GNU/Linux systems, and they are available as install options on BSD-based systems. Even proprietary UNIXes often have complete sets of GNU software laid atop them to bring them up to date with the modern world. Because GNU software can be obtained at little or no cost, there is no excuse to continue scripting in a retrograde proprietary environment.

I live in the San Francisco Bay Area, mere walking distance from one of the Bay Area Rapid Transit (BART) stations. I do not drive, so I rely on the system for my trips downtown. The BART Web site offers an on-line trip planner, but I perform the same sort of query often and find the interface less convenient than a command-line script.

In order to save time, I decided to write a shell script that would fetch the train arrival information for my station and display it in a colored ASCII table on stdout. It should accept station codes for any arbitrary trip but use defaults specified in a per-user configuration file. I did not want to write the schedule analysis code, so I decided to perform a screen scrape of the BART trip planner. wget would submit the trip planner form, and the resulting Web page would be formatted with various tools.

The first line of most shell scripts begins with #!/bin/sh, which causes the script to be interpreted by the venerable old Bourne shell. This is used largely because classic Bourne is the only shell guaranteed to be on all UNIX and UNIX-like systems. Because this script is designed to work in a modern GNU system, it begins with #!/bin/bash. Users of BSD systems may wish to change it to #!/usr/local/bin/bash or perhaps #!/usr/bin/env bash.

Using bash instead of the classic Bourne shell provides us with some useful features we can put to good use in a moment. For one thing, bash allows us to break down our script using functions. The bash string manipulation routines also can save us some time by performing operations in-line that otherwise would have to be fed into an external sed or awk process.

Any good program has configuration files, so we can set up a traditional rc filesystem. The rc at the end of many configuration files stands for run commands, and it typically refers to the fact that the configuration file is loaded in like a script.

	test -r /etc/bartrc && source /etc/bartrc
	test -r ~/.bartrc && source ~/.bartrc

We also should set the default departure and arrival station codes to Rockridge and Embarcadero, respectively. We use the compact bash syntax for an alternate value if a variable is undefined, so users can set the BARTSTART and BARTDEST variables in their own environments if they like.

	BARTSTART=${BARTSTART:-ROCKR}
	BARTDEST=${BARTDEST:-EMBAR}

The first function we write is the basic usage guideline message, which helps guide development of the rest of the program.

	function usage {
		echo "Usage:"
		echo " $(basename $0) [-hl] [ [<source>] <destination> ]"
		echo "  To change defaults, set the BARTSTART and BARTDEST"
		echo "  variables in your ~/.bartrc"
		echo
		echo "Flags:"
		echo "  -l, --list	List station codes with names"
		echo "  -h, --help	This message"
	}

We now have a simple usage command available that prints out the argument format for the script. Notice that we used $(basename $0) to determine automatically the filename of the script. We also allow an optional destination station code as an argument, which may be preceded by an optional departure station code.

HTTP has two methods for submitting selections to a form, GET and POST. The POST method is the most powerful, but the GET method allows us to specify values in the URL itself. This makes the GET method most convenient for scripting, because we can specify all relevant form fields as an argument to a simple tool, such as wget.

First, we set up the base URL to the form, specifying options to minimize the amount of formatting around the data.

	baseurl="http://bart.gov/textonly/stations/schedule.asp?ct=1&format=quick&print=yes"

Looking at the form's HTML source code, we determine which fields have which names and begin to construct additions to the above URL. The date we're interested in is the current moment, and we use the date command's own formatting options to construct the date and time portion of the form.

	date_now=$(date +"&time_mode=departs&depart_month=%m&depart_date=%d&depart_time=%I:%M+%p")

The $( ... ) syntax is simply a more explicit version of the backticks, allowing us to use the output of a command as part of a line of shell code.

Next, we use the BARTSTART and BARTDEST variables to enter the stations in which we are interested.

	stations="&origin=${BARTSTART}&destination=${BARTDEST}"

Then, we use the wget utility to submit the form, redirecting all warning messages to /dev/null so as not to confuse our script. The full function looks like this:

	function submitform {
		baseurl="http://bart.gov/textonly/stations/schedule.asp?ct=1&format=quick&print=yes"
		date_now=$(date +"&time_mode=departs&depart_month=%m&depart_date=%d&depart_time=%I:%M+%p")
		stations="&origin=${BARTSTART}&destination=${BARTDEST}"

		wget -O - -o /dev/null ${baseurl}${date_now}${stations}
	}