Add 'yaml' build tag for conditionally using gopkg.in/yaml.v2

So folks who are comfortable with the additional dependency can get
prove-compatible output.  Michael wants to stick with prove for tap-go
because it is widely installed [1], but folks using node-tap or other
consumers that can handle the JSON subset of YAML probably don't want
the external dependency.  Folks who want yaml.v2 can enable the yaml
build tag [2].  Folks who are ok with JSON don't have to set any build
tags.

The go-yaml dependency is the only Go producer listed in [3].  There
may be others, I haven't checked.

The Makefile changes include new uses of wildcards [4] to pick up
test/%/*.go siblings.  And I'm using the stem variable $* [5] in the
rule to pick up the whole test package (and not just main.go).

I'm not sure how Michael wants vendoring to work.  For the moment,
I've softened the 'GOPATH =' to a 'GOPATH ?=' and installed the
package in my local GOPATH.  It's possible that we want to stick with
'GOPATH =' and drop the package under gopath/ (via a Git submodule?).

[1]: mndrix/tap-go#7 (comment)
[2]: https://golang.org/pkg/go/build/#hdr-Build_Constraints
[3]: http://yaml.org/
[4]: https://www.gnu.org/software/make/manual/html_node/Wildcard-Examples.html
[5]: https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html

Author: wking

util/tap.go

@@ -21,7 +21,6 @@
 package tap // import "github.com/mndrix/tap-go"
 
 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -155,12 +154,12 @@ func (t *T) Diagnosticf(format string, a ...interface{}) {
 
 // YAML generates a YAML block from the message.
 func (t *T) YAML(message interface{}) error {
-	bytes, err := json.MarshalIndent(message, "  ", "  ")
+	bytes, err := yaml(message, "  ")
 	if err != nil {
 		return err
 	}
 	t.printf("  ---\n  ")
 	t.printf(string(bytes))
-	t.printf("\n  ...\n")
+	t.printf("  ...\n")
 	return nil
 }

util/yaml_json.go

@@ -0,0 +1,22 @@
+// +build !yaml
+
+package tap
+
+import (
+	"encoding/json"
+)
+
+// yaml serializes a message to YAML.  This implementation uses JSON,
+// which is a subset of YAML [1] and is implemented by Go's standard
+// library.
+//
+// [1]: http://www.yaml.org/spec/1.2/spec.html#id2759572
+func yaml(message interface{}, prefix string) (marshaled []byte, err error) {
+	marshaled, err = json.MarshalIndent(message, prefix, "  ")
+	if err != nil {
+		return marshaled, err
+	}
+
+	marshaled = append(marshaled, []byte("\n")...)
+	return marshaled, err
+}

util/yaml_yaml.go

@@ -0,0 +1,23 @@
+// +build yaml
+
+package tap
+
+import (
+	"bytes"
+
+	goyaml "gopkg.in/yaml.v2"
+)
+
+// yaml serializes a message to YAML.  This implementation uses
+// non-JSON YAML, which has better prove support [1].
+//
+// [1]: https://rt.cpan.org/Public/Bug/Display.html?id=121606
+func yaml(message interface{}, prefix string) (marshaled []byte, err error) {
+	marshaled, err = goyaml.Marshal(message)
+	if err != nil {
+		return marshaled, err
+	}
+
+	marshaled = bytes.Replace(marshaled, []byte("\n"), []byte("\n"+prefix), -1)
+	return marshaled[:len(marshaled)-len(prefix)], err
+}