introduction paragraph

* move shall reference to the right place
* further explain cross-shell testing methods

cross-shell-tests

@@ -6,7 +6,7 @@ for shell in dash bash ksh zsh; do
   if which $shell > /dev/null 2> /dev/null; then
     echo
     echo Running urchin tests in $shell
-    $shell urchin -s $shell tests | tail -n 3
+    $shell urchin tests | tail -n 3
   else
     echo
     echo Skipping $shell because it is not in the PATH

readme.md

@@ -4,9 +4,9 @@
     / /_/ / /  / /__/ / / / / / / /
     \__,_/_/   \___/_/ /_/_/_/ /_/ 
 
-Urchin is a test framework for shell. It is implemented in
-portable /bin/sh and should work on GNU/Linux, Mac OS X, and
-other Unix platforms.
+Urchin is a file-based test harness, normally used for testing shell programs.
+It is written in portable shell and should thus work on GNU/Linux, BSD
+(including Mac OS X), and other Unix-like platforms.
 
 ## Try it out
 Urchin's tests are written in Urchin, so you can run them to see what Urchin
@@ -27,14 +27,15 @@ run this:
     cd urchin
     ./cross-shell-tests
 
-## Globally
-Download Urchin like so (as root) (or use npm, below):
+## Install
+Urchin is contained in a single file, so you can install it by copying it to a
+directory in your `PATH`. For example, you can run the following as root.
 
     cd /usr/local/bin
     wget https://raw.github.com/tlevine/urchin/master/urchin
     chmod +x urchin
 
-Can be installed with npm too:
+Urchin can be installed with npm too.
 
     npm install -g urchin
 
@@ -86,15 +87,14 @@ Files are only run if they are executable, and files beginning with `.` are
 ignored. Thus, fixtures and libraries can be included sloppily within the test
 directory tree. The test passes if the file exits 0; otherwise, it fails.
 
-In case you care about the order in which your tests execute, consider that
+Tests files and subdirectories are run in ASCIIbetical order within each
+directory; that is,
 urchin looks for files within a directory in the following manner.
 
     for file in *; do
       do_something_with_test_file $file
     done
 
-Tests within a directory are executed in whatever order `*` returns.
-
 ### Writing cross-shell compatibility tests for testing shell code
 
 While you could write your test scripts to explicitly invoke the functionality
@@ -106,24 +106,20 @@ The specific approach depends on your test scenario:
 * (b) Your scripts _source_ scripts containing portable shell code.
 
 #### (a) Cross-shell tests with test scripts that _invoke_ shell scripts
+Urchin sets the `TEST_SHELL` environment variable so that you may change the
+shell with which your tests call other shell programs. To run your test
+scripts in multiple shells you must call `$TEST_SHELL` in your tests and then
+run urchin with the appropriate option.
 
-First, consider using [shall](https://github.com/mklement0/shall).
-
-    #!/usr/bin/env shall
-    echo This is a test file.
-
-Alternatively, you can use urchin's built-in recognition of the
-`TEST_SHELL` environment variable.
 In your test scripts, invoke the shell scripts to test via the shell
 specified in environment variable `TEST_SHELL` rather than directly;
 e.g.: `$TEST_SHELL ../foo bar` (rather than just `../foo bar`).  
-Note that if you alsow want your test scripts to work when run directly,
-outside of Urchin, be sure to target scripts that happen to be in the 
-current directory with prefix `./`; e.g., `$TEST_SHELL ./baz`
-(rather than `$TEST_SHELL baz`).
 
-Then, on invocation of Urchin, prepend a definition of environment variable
-`TEST_SHELL` specifying the shell to test with, e.g.: `TEST_SHELL=zsh urchin ./tests`.  
+On invocation of Urchin, prepend a definition of environment variable
+`TEST_SHELL` specifying the shell to test with, e.g.,
+
+    TEST_SHELL=zsh urchin ./tests
+
 To test with multiple shells in sequence, use something like:
 
     for shell in sh bash ksh zsh; do
@@ -131,14 +127,20 @@ To test with multiple shells in sequence, use something like:
     done
 
 If `TEST_SHELL` has no value, Urchin defines it as `/bin/sh`, so the test
-scripts can rely on `$TEST_SHELL` always containing a value.
+scripts can rely on `$TEST_SHELL` always containing a value when Urchin runs
+them.
+
+That said, we still recommand that you account for the possibility that
+`$TEST_SHELL` does not contain a value so that you may run your test scripts
+without Urchin. Supporting this case is very simple; when you invoke scripts
+that happen to be in the current directory, be sure to use the prefix `./`,
+e.g., `$TEST_SHELL ./baz` rather than `$TEST_SHELL baz`.
 
 #### (b) Cross-shell tests with test scripts that _source_ shell scripts
-
 If you _source_ shell code in your test scripts, it is the test scripts
 themselves that must be run with the shell specified.
 
-To that end, Urchin supports the `-s <shell>` option, which instructs
+Urchin supports the `-s <shell>` option, which instructs
 Urchin to invoke the test scripts with the specified shell; e.g., `-s bash`.  
 (In addition, Urchin sets environment variable `TEST_SHELL` to the specified
 shell.)
@@ -154,21 +156,12 @@ To test with multiple shells in sequence, use something like:
       urchin -s $shell ./tests
     done
 
-<!--
-#### (c) Cross shell tests with `urchin -x` (experimental)
-If you run urchin with the `-x` flag, it will be as if you ran
-`$TEST_SHELL`. Unless `$TEST_SHELL` isn't set, in which case it'll
-be as if you ran `/bin/sh`. Putting this in she shebang line might
-eventually work out to be a cleaner way of doing cross-shell testing.
+Also consider using [shall](https://github.com/mklement0/shall).
+It does something similar, but the interface may be more intuitive.
 
-    #!/usr/bin/env urchin -x
-    test a = a
+    #!/usr/bin/env shall
+    echo This is a test file.
 
-It might make sense if you do this.
-
-    export TEST_SHELL=zsh && urchin -x
-    export TEST_SHELL=bash && urchin -x
--->
 ## Alternatives to Urchin
 Alternatives to Urchin are discussed in
 [this blog post](https://blog.scraperwiki.com/2012/12/how-to-test-shell-scripts/).

tests/.die-on-fail/2 should run.

@@ -1 +0,0 @@
-false

tests/.die-on-fail/3 should not run.

@@ -1 +0,0 @@
-false

tests/.die-on-fail/4 should not run.

@@ -1 +0,0 @@
-false

tests/Die on fail.

@@ -1,11 +0,0 @@
-tmp=$(mktemp)
-../urchin -e -f ./.die-on-fail > $tmp
-result=$?
-
-grep '1 should run.' $tmp
-grep '2 should run.' $tmp
-grep -v '3 should not run.' $tmp
-grep -v '4 should not run.' $tmp
-
-rm $tmp
-exit $result

tests/urchin -x should start the $TEST_SHELL.

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+test c = $(../urchin -x .print-arg-3 a 'b b b b' c d e)

urchin

@@ -47,13 +47,6 @@ recurse() {
 
         # $2 instead of $indent_level so it doesn't clash
         recurse "${test}" $(( $2 + 1 )) "$shell_for_sh_tests"
-        exit_code=$?
-
-        if $exit_on_fail && test $exit_code -ne 0; then
-          [ -f teardown ] && [ -x teardown ] && ./teardown >> "$stdout_file"
-          [ -f teardown_dir ] && [ -x teardown_dir ] && ./teardown_dir >> "$stdout_file"
-          return 1
-        fi
 
         [ -f teardown ] && [ -x teardown ] && ./teardown >> "$stdout_file"
       done
@@ -74,6 +67,7 @@ recurse() {
     fi
     exit_code="$?"
 
+
     [ -f teardown ] && [ -x teardown ] && ./teardown >> "$stdout_file"
 
     indent $indent_level
@@ -92,10 +86,6 @@ recurse() {
       cat "$stdout_file"
       printf '\033[0m'
     fi
-
-    if $exit_on_fail && test 0 -ne $exit_code; then
-      return 1
-    fi
   fi
   [ $indent_level -eq 0 ] && rm "$stdout_file"
 }
@@ -115,9 +105,6 @@ $USAGE
 
 -s <shell>  Invoke test scripts that either have no shebang line at all or
             have shebang line "#!/bin/sh" with the specified shell.
--e          Stop running if any single test fails. This is helpful if you want
-            to use Urchin to run things other than tests, such as a set of
-            configuration scripts.
 -f          Force running even if the test directory's name does not
             contain the word "test".
 -h          This help.
@@ -125,6 +112,10 @@ $USAGE
 Go to https://github.com/tlevine/urchin for documentation on writing tests.
 
 EOF
+  # [Experimental -x option left undocumented for now.]
+  # -x          [Experimental; not meant for direct invocation, but for use in
+  #             the shebang line of test scripts]
+  #             Run with "\$TEST_SHELL", falling back on /bin/sh.
 }
 
 plural () {
@@ -183,17 +174,20 @@ urchin_molly_guard() {
 
 shell_for_sh_tests=
 force=false
-exit_on_fail=false
 while [ $# -gt 0 ]
 do
     case "$1" in
-        -e) exit_on_fail=true;;
         -f) force=true;;
         -s)
           shift
           shell_for_sh_tests=$1
           which "$shell_for_sh_tests" >/dev/null || { echo "Cannot find specified shell: '$shell_for_sh_tests'" >&2; urchin_help >&2; exit 2; }
           ;;
+        -x) # [EXPERIMENTAL; UNDOCUMENTED FOR NOW] `urchin -x <test-script>` in a test script's shebang line is equivalent to invoking that script with `"$TEST_SHELL" <test-script>`
+          shift
+          urchinsh=${TEST_SHELL:-/bin/sh}
+          "$urchinsh" "$@"
+          exit $?;;
         -h|--help) urchin_help
           exit 0;;
         -*) urchin_help >&2