Change JQ to process newline-delimited JSON

https://jsonlines.org

Example use case:

Analyzes logs to count and display frequency of different log levels
from newline-delimited JSON input.

```
cat log.json | ./goscript.sh -c 'script.Stdin().JQ(".level").Freq().Stdout()'
3 "INFO"
2 "WARN"
1 "ERROR"
```

Author: tho

script.go

@@ -712,9 +712,10 @@ func (p *Pipe) Join() *Pipe {
 	})
 }
 
-// JQ executes query on the pipe's contents (presumed to be JSON), producing
-// the result. An invalid query will set the appropriate error on the pipe.
-//
+// JQ executes query on the pipe's contents (presumed to be newline-delimited
+// JSON), applying the query to each input value and producing the results. An
+// invalid query or value will set the appropriate error on the pipe.
+
 // The exact dialect of JQ supported is that provided by
 // [github.com/itchyny/gojq], whose documentation explains the differences
 // between it and standard JQ.
@@ -724,26 +725,34 @@ func (p *Pipe) JQ(query string) *Pipe {
 		if err != nil {
 			return err
 		}
-		var input interface{}
-		err = json.NewDecoder(r).Decode(&input)
+		c, err := gojq.Compile(q)
 		if err != nil {
 			return err
 		}
-		iter := q.Run(input)
-		for {
-			v, ok := iter.Next()
-			if !ok {
-				return nil
-			}
-			if err, ok := v.(error); ok {
-				return err
-			}
-			result, err := gojq.Marshal(v)
+		dec := json.NewDecoder(r)
+		for dec.More() {
+			var input interface{}
+			err := dec.Decode(&input)
 			if err != nil {
 				return err
 			}
-			fmt.Fprintln(w, string(result))
+			iter := c.Run(input)
+			for {
+				v, ok := iter.Next()
+				if !ok {
+					break
+				}
+				if err, ok := v.(error); ok {
+					return err
+				}
+				result, err := gojq.Marshal(v)
+				if err != nil {
+					return err
+				}
+				fmt.Fprintln(w, string(result))
+			}
 		}
+		return nil
 	})
 }
 

script_test.go

@@ -804,6 +804,59 @@ func TestJQHandlesGithubJSONWithRealWorldExampleQuery(t *testing.T) {
 	}
 }
 
+func TestJQWithNewlineDelimitedInputAndFieldQueryProducesSelectedFields(t *testing.T) {
+	t.Parallel()
+	input := `{"timestamp": 1649264191, "iss_position": {"longitude": "52.8439", "latitude": "10.8107"}, "message": "success"}` + "\n"
+	input += input
+	want := `{"latitude":"10.8107","longitude":"52.8439"}` + "\n"
+	want += want
+	got, err := script.Echo(input).JQ(".iss_position").String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want != got {
+		t.Error(want, got)
+		t.Error(cmp.Diff(want, got))
+	}
+}
+
+func TestJQWithNewlineDelimitedInputAndArrayInputAndElementQueryProducesSelectedElements(t *testing.T) {
+	t.Parallel()
+	input := `[1, 2, 3]` + "\n" + `[4, 5, 6]`
+	want := "1\n4\n"
+	got, err := script.Echo(input).JQ(".[0]").String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want != got {
+		t.Error(want, got)
+		t.Error(cmp.Diff(want, got))
+	}
+}
+
+func TestJQWithNewlineDelimitedMixedAndPrettyPrintedInputValues(t *testing.T) {
+	t.Parallel()
+	input := `
+{
+  "key1": "val1",
+  "key2": "val2"
+}
+[
+  0,
+  1
+]
+`
+	want := `{"key1":"val1","key2":"val2"}` + "\n" + "[0,1]" + "\n"
+	got, err := script.Echo(input).JQ(".").String()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want != got {
+		t.Error(want, got)
+		t.Error(cmp.Diff(want, got))
+	}
+}
+
 func TestJQErrorsWithInvalidQuery(t *testing.T) {
 	t.Parallel()
 	input := `[1, 2, 3]`
@@ -813,6 +866,29 @@ func TestJQErrorsWithInvalidQuery(t *testing.T) {
 	}
 }
 
+func TestJQErrorsWithInvalidInput(t *testing.T) {
+	t.Parallel()
+	input := "invalid JSON value"
+	_, err := script.Echo(input).JQ(".").String()
+	if err == nil {
+		t.Error("want error from invalid JSON input, got nil")
+	}
+}
+
+func TestJQWithNewlineDelimitedInputErrorsAfterFirstInvalidInput(t *testing.T) {
+	t.Parallel()
+	input := `[0]` + "\n" + `[1` + "\n" + `[2]` // missing `]` in second line
+	want := "0\n"
+	got, err := script.Echo(input).JQ(".[0]").String()
+	if err == nil {
+		t.Fatal("want error from invalid JSON, got nil")
+	}
+	if want != got {
+		t.Error(want, got)
+		t.Error(cmp.Diff(want, got))
+	}
+}
+
 func TestLastDropsAllButLastNLinesOfInput(t *testing.T) {
 	t.Parallel()
 	input := "a\nb\nc\n"