Bump version

json.Encoder and json.Marshal implicitly use HTMLEscape to convert
>, <, &, with \u003c, \u003e, \u0026. This behavior carries over
to yq, where chars will be escaped when outputting json but not when
outputting yaml.

This changeset disables this behavior via encoder.SetEscapeHTML(false).
Unfortunately there is no equivalent option for json.Marshal, so its
single usage has been replaced with an encoder (with escaping disabled).

cmd/version.go

@@ -11,7 +11,7 @@ var (
 	GitDescribe string
 
 	// Version is main version number that is being run at the moment.
-	Version = "4.4.0"
+	Version = "4.4.1"
 
 	// VersionPrerelease is a pre-release marker for the version. If this is "" (empty string)
 	// then it means that it is a final release. Otherwise, this is a pre-release

github-action/Dockerfile

@@ -1,4 +1,4 @@
-FROM mikefarah/yq:4.4.0
+FROM mikefarah/yq:4.4.1
 
 COPY entrypoint.sh /entrypoint.sh
 

pkg/yqlib/doc/Add.md

@@ -209,3 +209,15 @@ will output
 a: 4
 ```
 
+## Add to null
+Adding to null simply returns the rhs
+
+Running
+```bash
+yq eval --null-input 'null + "cat"'
+```
+will output
+```yaml
+cat
+```
+

pkg/yqlib/encoder.go

@@ -76,6 +76,8 @@ func mapKeysToStrings(node *yaml.Node) {
 
 func NewJsonEncoder(destination io.Writer, indent int) Encoder {
 	var encoder = json.NewEncoder(destination)
+	encoder.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
+
 	var indentString = ""
 
 	for index := 0; index < indent; index++ {
@@ -153,11 +155,15 @@ func (o *orderedMap) UnmarshalJSON(data []byte) error {
 }
 
 func (o orderedMap) MarshalJSON() ([]byte, error) {
-	if o.kv == nil {
-		return json.Marshal(o.altVal)
-	}
 	buf := new(bytes.Buffer)
 	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(false) // do not escape html chars e.g. &, <, >
+	if o.kv == nil {
+		if err := enc.Encode(o.altVal); err != nil {
+			return nil, err
+		}
+		return buf.Bytes(), nil
+	}
 	buf.WriteByte('{')
 	for idx, el := range o.kv {
 		if err := enc.Encode(el.K); err != nil {

pkg/yqlib/encoder_test.go

@@ -9,29 +9,11 @@ import (
 	"github.com/mikefarah/yq/v4/test"
 )
 
-var sampleYaml = `zabbix: winner
+func yamlToJson(sampleYaml string, indent int) string {
-apple: great
-banana:
-- {cobra: kai, angus: bob}
-`
-
-var expectedJson = `{
-  "zabbix": "winner",
-  "apple": "great",
-  "banana": [
-    {
-      "cobra": "kai",
-      "angus": "bob"
-    }
-  ]
-}
-`
-
-func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
 	var output bytes.Buffer
 	writer := bufio.NewWriter(&output)
 
-	var jsonEncoder = NewJsonEncoder(writer, 2)
+	var jsonEncoder = NewJsonEncoder(writer, indent)
 	inputs, err := readDocuments(strings.NewReader(sampleYaml), "sample.yml", 0)
 	if err != nil {
 		panic(err)
@@ -42,6 +24,33 @@ func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
 		panic(err)
 	}
 	writer.Flush()
-	test.AssertResult(t, expectedJson, output.String())
 
+	return strings.TrimSuffix(output.String(), "\n")
+}
+
+func TestJsonEncoderPreservesObjectOrder(t *testing.T) {
+	var sampleYaml = `zabbix: winner
+apple: great
+banana:
+- {cobra: kai, angus: bob}
+`
+	var expectedJson = `{
+  "zabbix": "winner",
+  "apple": "great",
+  "banana": [
+    {
+      "cobra": "kai",
+      "angus": "bob"
+    }
+  ]
+}`
+	var actualJson = yamlToJson(sampleYaml, 2)
+	test.AssertResult(t, expectedJson, actualJson)
+}
+
+func TestJsonEncoderDoesNotEscapeHTMLChars(t *testing.T) {
+	var sampleYaml = `build: "( ./lint && ./format && ./compile ) < src.code"`
+	var expectedJson = `{"build":"( ./lint && ./format && ./compile ) < src.code"}`
+	var actualJson = yamlToJson(sampleYaml, 0)
+	test.AssertResult(t, expectedJson, actualJson)
 }

pkg/yqlib/operator_add.go

@@ -47,9 +47,14 @@ func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*Candida
 	lhs.Node = unwrapDoc(lhs.Node)
 	rhs.Node = unwrapDoc(rhs.Node)
 
-	target := lhs.CreateChild(nil, &yaml.Node{})
 	lhsNode := lhs.Node
 
+	if lhsNode.Tag == "!!null" {
+		return lhs.CreateChild(nil, rhs.Node), nil
+	}
+
+	target := lhs.CreateChild(nil, &yaml.Node{})
+
 	switch lhsNode.Kind {
 	case yaml.MappingNode:
 		return nil, fmt.Errorf("Maps not yet supported for addition")

pkg/yqlib/operator_add_test.go

@@ -112,6 +112,14 @@ var addOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: 4}\n",
 		},
 	},
+	{
+		description:    "Add to null",
+		subdescription: "Adding to null simply returns the rhs",
+		expression:     `null + "cat"`,
+		expected: []string{
+			"D0, P[], (!!str)::cat\n",
+		},
+	},
 }
 
 func TestAddOperatorScenarios(t *testing.T) {

pkg/yqlib/operator_multiply_test.go

@@ -144,6 +144,14 @@ b:
 			"D0, P[a], (!!seq)::[{thing: two}]\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: {array: [1]}, b: {}}`,
+		expression: `.b *+ .a`,
+		expected: []string{
+			"D0, P[b], (!!map)::{array: [1]}\n",
+		},
+	},
 	{
 		description: "Merge, appending arrays",
 		document:    `{a: {array: [1, 2, animal: dog], value: coconut}, b: {array: [3, 4, animal: cat], value: banana}}`,

snap/snapcraft.yaml

@@ -1,5 +1,5 @@
 name: yq
-version: '4.4.0'
+version: '4.4.1'
 summary: A lightweight and portable command-line YAML processor
 description: |
   The aim of the project is to be the jq or sed of yaml files.