Can update a yaml file from an instruction yaml file

README.md

@@ -1,16 +1,18 @@
 # yaml
-yaml command line tool written in go
+yaml is portable command line tool written in go
 
-Allows you to read (and soon update) yaml files given a yaml path.
+Allows you to read and update yaml files from bash (or whatever). All in a lovely dependency free binary!
 
-## Install
+[Download latest release](https://github.com/mikefarah/yaml/releases/latest)
+
+or alternatively install using go get:
 ```
 go get github.com/mikefarah/yaml
 ```
 
 ## Read examples
 ```
-yaml <yaml file> <path>
+yaml r <yaml file> <path>
 ```
 
 ### Basic
@@ -21,7 +23,46 @@ b:
 ```
 then
 ```bash
-yaml sample.yaml b.c
+yaml r sample.yaml b.c
+```
+will output the value of '2'.
+
+### Reading from STDIN
+Given a sample.yaml file of:
+```bash
+cat sample.yaml | yaml r - b.c
+```
+will output the value of '2'.
+
+### Splat
+Given a sample.yaml file of:
+```yaml
+---
+bob:
+  item1:
+    cats: bananas
+  item2:
+    cats: apples
+```
+then
+```bash
+yaml r sample.yaml bob.*.cats
+```
+will output
+```yaml
+- bananas
+- apples
+```
+
+### Handling '.' in the yaml key
+Given a sample.yaml file of:
+```yaml
+b.x:
+  c: 2
+```
+then
+```bash
+yaml r sample.yaml \"b.x\".c
 ```
 will output the value of '2'.
 
@@ -38,10 +79,84 @@ b:
 ```
 then
 ```
-yaml sample.yaml b.e.1.name
+yaml r sample.yaml b.e[1].name
 ```
 will output 'sam'
 
-## TODO
-* Updating yaml files
-* Handling '.' in path names
+### Array Splat
+e.g.: given a sample file of
+```yaml
+b:
+  e:
+    - name: fred
+      value: 3
+    - name: sam
+      value: 4
+```
+then
+```
+yaml r sample.yaml b.e[*].name
+```
+will output:
+```
+- fred
+- sam
+```
+
+## Update examples
+
+### Update to stdout
+Given a sample.yaml file of:
+```yaml
+b:
+  c: 2
+```
+then
+```bash
+yaml w sample.yaml b.c cat
+```
+will output:
+```yaml
+b:
+  c: cat
+```
+
+### Updating yaml in-place
+Given a sample.yaml file of:
+```yaml
+b:
+  c: 2
+```
+then
+```bash
+yaml w -i sample.yaml b.c cat
+```
+will update the sample.yaml file so that the value of 'c' is cat.
+
+
+### Updating multiple values with a script
+Given a sample.yaml file of:
+```yaml
+b:
+  c: 2
+  e:
+    - name: Billy Bob
+```
+and a script update_instructions.yaml of:
+```yaml
+b.c: 3
+b.e[0].name: Howdy Partner
+```
+then
+
+```bash
+yaml -w -s update_instructions.yaml sample.yaml
+```
+will output:
+```yaml
+b:
+  c: 3
+  e:
+    - name: Howdy Partner
+```
+

data_navigator.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	// "fmt"
+	"strconv"
+)
+
+func write(context map[interface{}]interface{}, head string, tail []string, value interface{}) {
+	if len(tail) == 0 {
+		context[head] = value
+	} else {
+		// e.g. if updating a.b.c, we need to get the 'b' map...
+		toUpdate := readMap(context, head, tail[0:len(tail)-1]).(map[interface{}]interface{})
+		//  and then set the 'c' key.
+		key := (tail[len(tail)-1])
+		toUpdate[key] = value
+	}
+}
+
+func readMap(context map[interface{}]interface{}, head string, tail []string) interface{} {
+	if head == "*" {
+		return readMapSplat(context, tail)
+	}
+	value := context[head]
+	return calculateValue(value, tail)
+}
+
+func readMapSplat(context map[interface{}]interface{}, tail []string) interface{} {
+	var newArray = make([]interface{}, len(context))
+	var i = 0
+	for _, value := range context {
+		if len(tail) > 0 {
+			newArray[i] = recurse(value, tail[0], tail[1:len(tail)])
+		} else {
+			newArray[i] = value
+		}
+		i++
+	}
+	return newArray
+}
+
+func recurse(value interface{}, head string, tail []string) interface{} {
+	switch value.(type) {
+	case []interface{}:
+		if head == "*" {
+			return readArraySplat(value.([]interface{}), tail)
+		}
+		index, err := strconv.ParseInt(head, 10, 64)
+		if err != nil {
+			die("Error accessing array: %v", err)
+		}
+		return readArray(value.([]interface{}), index, tail)
+	case map[interface{}]interface{}:
+		return readMap(value.(map[interface{}]interface{}), head, tail)
+	default:
+		return nil
+	}
+}
+
+func readArray(array []interface{}, head int64, tail []string) interface{} {
+	if head > int64(len(array)) {
+		return nil
+	}
+
+	value := array[head]
+
+	return calculateValue(value, tail)
+}
+
+func readArraySplat(array []interface{}, tail []string) interface{} {
+	var newArray = make([]interface{}, len(array))
+	for index, value := range array {
+		newArray[index] = calculateValue(value, tail)
+	}
+	return newArray
+}
+
+func calculateValue(value interface{}, tail []string) interface{} {
+	if len(tail) > 0 {
+		return recurse(value, tail[0], tail[1:len(tail)])
+	}
+	return value
+}

data_navigator_test.go

@@ -0,0 +1,146 @@
+package main
+
+import (
+	"fmt"
+	"gopkg.in/yaml.v2"
+	"os"
+	"sort"
+	"testing"
+)
+
+func parseData(rawData string) map[interface{}]interface{} {
+	var parsedData map[interface{}]interface{}
+	err := yaml.Unmarshal([]byte(rawData), &parsedData)
+	if err != nil {
+		fmt.Println("Error parsing yaml: %v", err)
+		os.Exit(1)
+	}
+	return parsedData
+}
+
+func TestReadMap_simple(t *testing.T) {
+	var data = parseData(`
+---
+b:
+  c: 2
+`)
+	assertResult(t, 2, readMap(data, "b", []string{"c"}))
+}
+
+func TestReadMap_splat(t *testing.T) {
+	var data = parseData(`
+---
+mapSplat:
+  item1: things
+  item2: whatever
+`)
+	var result = readMap(data, "mapSplat", []string{"*"}).([]interface{})
+	var actual = []string{result[0].(string), result[1].(string)}
+	sort.Strings(actual)
+	assertResult(t, "[things whatever]", fmt.Sprintf("%v", actual))
+}
+
+func TestReadMap_deep_splat(t *testing.T) {
+	var data = parseData(`
+---
+mapSplatDeep:
+  item1:
+    cats: bananas
+  item2:
+    cats: apples
+`)
+
+	var result = readMap(data, "mapSplatDeep", []string{"*", "cats"}).([]interface{})
+	var actual = []string{result[0].(string), result[1].(string)}
+	sort.Strings(actual)
+	assertResult(t, "[apples bananas]", fmt.Sprintf("%v", actual))
+}
+
+func TestReadMap_key_doesnt_exist(t *testing.T) {
+	var data = parseData(`
+---
+b:
+  c: 2
+`)
+	assertResult(t, nil, readMap(data, "b.x.f", []string{"c"}))
+}
+
+func TestReadMap_recurse_against_string(t *testing.T) {
+	var data = parseData(`
+---
+a: cat
+`)
+	assertResult(t, nil, readMap(data, "a", []string{"b"}))
+}
+
+func TestReadMap_with_array(t *testing.T) {
+	var data = parseData(`
+---
+b:
+  d:
+    - 3
+    - 4
+`)
+	assertResult(t, 4, readMap(data, "b", []string{"d", "1"}))
+}
+
+func TestReadMap_with_array_out_of_bounds(t *testing.T) {
+	var data = parseData(`
+---
+b:
+  d:
+    - 3
+    - 4
+`)
+	assertResult(t, nil, readMap(data, "b", []string{"d", "3"}))
+}
+
+func TestReadMap_with_array_splat(t *testing.T) {
+	var data = parseData(`
+e:
+  -
+    name: Fred
+    thing: cat
+  -
+    name: Sam
+    thing: dog
+`)
+	assertResult(t, "[Fred Sam]", fmt.Sprintf("%v", readMap(data, "e", []string{"*", "name"})))
+}
+
+func TestWrite_simple(t *testing.T) {
+	var data = parseData(`
+b:
+  c: 2
+`)
+
+	write(data, "b", []string{"c"}, "4")
+
+	b := data["b"].(map[interface{}]interface{})
+	assertResult(t, "4", b["c"].(string))
+}
+
+func TestWrite_with_no_tail(t *testing.T) {
+	var data = parseData(`
+b:
+  c: 2
+`)
+	write(data, "b", []string{}, "4")
+
+	b := data["b"]
+	assertResult(t, "4", fmt.Sprintf("%v", b))
+}
+
+func assertResult(t *testing.T, expectedValue interface{}, actualValue interface{}) {
+	if expectedValue != actualValue {
+		t.Error("Expected <", expectedValue, "> but got <", actualValue, ">", fmt.Sprintf("%T", actualValue))
+	}
+}
+
+func assertResultWithContext(t *testing.T, expectedValue interface{}, actualValue interface{}, context interface{}) {
+
+	if expectedValue != actualValue {
+		t.Error(context)
+		t.Error(": expected <", expectedValue, "> but got <", actualValue, ">")
+	}
+}

instruction_sample.yaml

@@ -0,0 +1,2 @@
+b.c: cat
+b.e[0].name: Mike Farah

path_parser.go

@@ -0,0 +1,55 @@
+package main
+
+func parsePath(path string) []string {
+	return parsePathAccum([]string{}, path)
+}
+
+func parsePathAccum(paths []string, remaining string) []string {
+	head, tail := nextYamlPath(remaining)
+	if tail == "" {
+		return append(paths, head)
+	}
+	return parsePathAccum(append(paths, head), tail)
+}
+
+func nextYamlPath(path string) (pathElement string, remaining string) {
+	switch path[0] {
+	case '[':
+		// e.g [0].blah.cat -> we need to return "0" and "blah.cat"
+		return search(path[1:len(path)], []uint8{']'}, true)
+	case '"':
+		// e.g "a.b".blah.cat -> we need to return "a.b" and "blah.cat"
+		return search(path[1:len(path)], []uint8{'"'}, true)
+	default:
+		// e.g "a.blah.cat" -> return "a" and "blah.cat"
+		return search(path[0:len(path)], []uint8{'.', '['}, false)
+	}
+}
+
+func search(path string, matchingChars []uint8, skipNext bool) (pathElement string, remaining string) {
+	for i := 0; i < len(path); i++ {
+		var char = path[i]
+		if contains(matchingChars, char) {
+			var remainingStart = i + 1
+			if skipNext {
+				remainingStart = remainingStart + 1
+			} else if !skipNext && char != '.' {
+				remainingStart = i
+			}
+			if remainingStart > len(path) {
+				remainingStart = len(path)
+			}
+			return path[0:i], path[remainingStart:len(path)]
+		}
+	}
+	return path, ""
+}
+
+func contains(matchingChars []uint8, candidate uint8) bool {
+	for _, a := range matchingChars {
+		if a == candidate {
+			return true
+		}
+	}
+	return false
+}

path_parser_test.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"testing"
+)
+
+var parsePathsTests = []struct {
+	path          string
+	expectedPaths []string
+}{
+	{"a.b", []string{"a", "b"}},
+	{"a.b[0]", []string{"a", "b", "0"}},
+}
+
+func testParsePath(t *testing.T) {
+	for _, tt := range parsePathsTests {
+		assertResultWithContext(t, tt.expectedPaths, parsePath(tt.path), tt)
+	}
+}
+
+var nextYamlPathTests = []struct {
+	path              string
+	expectedElement   string
+	expectedRemaining string
+}{
+	{"a.b", "a", "b"},
+	{"a", "a", ""},
+	{"a.b.c", "a", "b.c"},
+	{"\"a.b\".c", "a.b", "c"},
+	{"a.\"b.c\".d", "a", "\"b.c\".d"},
+	{"[1].a.d", "1", "a.d"},
+	{"a[0].c", "a", "[0].c"},
+	{"[0]", "0", ""},
+}
+
+func TestNextYamlPath(t *testing.T) {
+	for _, tt := range nextYamlPathTests {
+		var element, remaining = nextYamlPath(tt.path)
+		assertResultWithContext(t, tt.expectedElement, element, tt)
+		assertResultWithContext(t, tt.expectedRemaining, remaining, tt)
+	}
+}

precheckin.sh

@@ -5,9 +5,13 @@ golint
 go test
 
 # acceptance test
-X=$(go run yaml.go  sample.yaml b.c)
+go build
+X=$(./yaml r sample.yaml b.c)
 
 if [ $X != 2 ]
   then
 	echo "Failed acceptance test: expected 2 but was $X"
+  exit 1
 fi
+
+go install

sample2.yaml

@@ -1,4 +1,9 @@
 a: Easy! as one two three
 b:
-  c: 3
-  d: [3, 4]
+  c: things
+  d: whatever
+things:
+ thing1:
+  cat: 'fred'
+ thing2:
+  cat: 'sam'

yaml.go

@@ -2,91 +2,165 @@ package main
 
 import (
 	"fmt"
-	"github.com/codegangsta/cli"
+	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v2"
 	"io/ioutil"
-	"log"
 	"os"
 	"strconv"
 	"strings"
 )
 
+var trimOutput = true
+var writeInplace = false
+var writeScript = ""
+
 func main() {
-	app := cli.NewApp()
-	app.Name = "yaml"
-	app.Usage = "command line tool for reading and writing yaml"
-	app.Commands = []cli.Command{
-		{
-			Name:    "read",
-			Aliases: []string{"r"},
-			Usage:   "read <filename> <path>\n\te.g.: yaml read sample.json a.b.c\n\t(default) reads a property from a given yaml file",
-			Action:  readProperty,
-		},
+	var cmdRead = &cobra.Command{
+		Use:     "read [yaml_file] [path]",
+		Aliases: []string{"r"},
+		Short:   "yaml r sample.yaml a.b.c",
+		Example: `
+yaml read things.yaml a.b.c
+yaml r - a.b.c (reads from stdin)
+yaml r things.yaml a.*.c
+yaml r things.yaml a.array[0].blah
+yaml r things.yaml a.array[*].blah
+			`,
+		Long: "Outputs the value of the given path in the yaml file to STDOUT",
+		Run:  readProperty,
 	}
-	app.Action = readProperty
-	app.Run(os.Args)
+
+	var cmdWrite = &cobra.Command{
+		Use:     "write [yaml_file] [path] [value]",
+		Aliases: []string{"w"},
+		Short:   "yaml w [--inplace/-i] sample.yaml a.b.c newValueForC",
+		Example: `
+yaml write things.yaml a.b.c cat
+yaml write --inplace things.yaml a.b.c cat
+yaml w -i things.yaml a.b.c cat
+			`,
+		Long: `Updates the yaml file w.r.t the given path and value.
+Outputs to STDOUT unless the inplace flag is used, in which case the file is updated instead.`,
+		Run: writeProperty,
+	}
+	cmdWrite.PersistentFlags().BoolVarP(&writeInplace, "inplace", "i", false, "update the yaml file inplace")
+	cmdWrite.PersistentFlags().StringVarP(&writeScript, "script", "s", "", "yaml script for updating yaml")
+
+	var rootCmd = &cobra.Command{Use: "yaml"}
+	rootCmd.PersistentFlags().BoolVarP(&trimOutput, "trim", "t", true, "trim yaml output")
+	rootCmd.AddCommand(cmdRead, cmdWrite)
+	rootCmd.Execute()
 }
 
-func readProperty(c *cli.Context) {
+func readProperty(cmd *cobra.Command, args []string) {
 	var parsedData map[interface{}]interface{}
-	readYaml(c, &parsedData)
 
-	var path = c.Args()[1]
-	var paths = strings.Split(path, ".")
+	readYaml(args[0], &parsedData)
 
-	fmt.Println(readMap(parsedData, paths[0], paths[1:len(paths)]))
-}
-
-func readYaml(c *cli.Context, parsedData *map[interface{}]interface{}) {
-	if len(c.Args()) == 0 {
-		log.Fatalf("Must provide filename")
-	}
-	var rawData = readFile(c.Args()[0])
-
-	if len(c.Args()) == 1 {
-		fmt.Println(string(rawData[:]))
+	if len(args) == 1 {
+		printYaml(parsedData)
 		os.Exit(0)
 	}
 
-	err := yaml.Unmarshal([]byte(rawData), &parsedData)
-	if err != nil {
-		log.Fatalf("error: %v", err)
+	var paths = parsePath(args[1])
+
+	printYaml(readMap(parsedData, paths[0], paths[1:len(paths)]))
+}
+
+func writeProperty(cmd *cobra.Command, args []string) {
+	var writeCommands map[string]interface{}
+	if writeScript != "" {
+		readYaml(writeScript, &writeCommands)
+	} else if len(args) < 3 {
+		die("Must provide <filename> <path_to_update> <value>")
+	} else {
+		writeCommands[args[1]] = parseValue(args[2])
 	}
+
+	var parsedData map[interface{}]interface{}
+	readYaml(args[0], &parsedData)
+
+	for path, value := range writeCommands {
+		var paths = parsePath(path)
+		write(parsedData, paths[0], paths[1:len(paths)], value)
+	}
+
+	if writeInplace {
+		ioutil.WriteFile(args[0], []byte(yamlToString(parsedData)), 0644)
+	} else {
+		printYaml(parsedData)
+	}
+}
+func parseValue(argument string) interface{} {
+	var value, err interface{}
+	var inQuotes = argument[0] == '"'
+	if !inQuotes {
+		value, err = strconv.ParseFloat(argument, 64)
+		if err == nil {
+			return value
+		}
+		value, err = strconv.ParseBool(argument)
+		if err == nil {
+			return value
+		}
+		return argument
+	}
+	return argument[1 : len(argument)-1]
+}
+
+func printYaml(context interface{}) {
+	fmt.Println(yamlToString(context))
+}
+
+func yamlToString(context interface{}) string {
+	out, err := yaml.Marshal(context)
+	if err != nil {
+		die("error printing yaml: %v", err)
+	}
+	outStr := string(out)
+	// trim the trailing new line as it's easier for a script to add
+	// it in if required than to remove it
+	if trimOutput {
+		return strings.Trim(outStr, "\n ")
+	}
+	return outStr
+}
+
+func readYaml(filename string, parsedData interface{}) {
+	if filename == "" {
+		die("Must provide filename")
+	}
+
+	var rawData []byte
+	if filename == "-" {
+		rawData = readStdin()
+	} else {
+		rawData = readFile(filename)
+	}
+
+	err := yaml.Unmarshal([]byte(rawData), parsedData)
+	if err != nil {
+		die("error: %v", err)
+	}
+}
+
+func readStdin() []byte {
+	bytes, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		die("error reading stdin", err)
+	}
+	return bytes
 }
 
 func readFile(filename string) []byte {
 	var rawData, readError = ioutil.ReadFile(filename)
 	if readError != nil {
-		log.Fatalf("error: %v", readError)
+		die("error: %v", readError)
 	}
 	return rawData
 }
 
-func readMap(context map[interface{}]interface{}, head string, tail []string) interface{} {
-	value := context[head]
-	if len(tail) > 0 {
-		return recurse(value, tail[0], tail[1:len(tail)])
-	}
-	return value
-}
-
-func recurse(value interface{}, head string, tail []string) interface{} {
-	switch value.(type) {
-	case []interface{}:
-		index, err := strconv.ParseInt(head, 10, 64)
-		if err != nil {
-			log.Fatalf("Error accessing array: %v", err)
-		}
-		return readArray(value.([]interface{}), index, tail)
-	default:
-		return readMap(value.(map[interface{}]interface{}), head, tail)
-	}
-}
-
-func readArray(array []interface{}, head int64, tail []string) interface{} {
-	value := array[head]
-	if len(tail) > 0 {
-		return recurse(value, tail[0], tail[1:len(tail)])
-	}
-	return value
+func die(message ...interface{}) {
+	fmt.Println(message)
+	os.Exit(1)
 }

yaml_test.go

@@ -1,41 +1,22 @@
 package main
 
 import (
-	"fmt"
-	"gopkg.in/yaml.v2"
-	"os"
 	"testing"
 )
 
-var rawData = `
-a: Easy!
-b:
-  c: 2
-  d: [3, 4]
-`
-
-var parsedData map[interface{}]interface{}
-
-func TestMain(m *testing.M) {
-	err := yaml.Unmarshal([]byte(rawData), &parsedData)
-	if err != nil {
-		fmt.Println("Error parsing yaml: %v", err)
-		os.Exit(1)
-	}
-
-	os.Exit(m.Run())
+var parseValueTests = []struct {
+	argument        string
+	expectedResult  interface{}
+	testDescription string
+}{
+	{"true", true, "boolean"},
+	{"\"true\"", "true", "boolean as string"},
+	{"3.4", 3.4, "number"},
+	{"\"3.4\"", "3.4", "number as string"},
 }
 
-func TestReadMap_simple(t *testing.T) {
-	result := readMap(parsedData, "b", []string{"c"})
-	if result != 2 {
-		t.Error("Excpted 2 but got ", result)
-	}
-}
-
-func TestReadMap_array(t *testing.T) {
-	result := readMap(parsedData, "b", []string{"d", "1"})
-	if result != 4 {
-		t.Error("Excpted 4 but got ", result)
+func TestParseValue(t *testing.T) {
+	for _, tt := range parseValueTests {
+		assertResultWithContext(t, tt.expectedResult, parseValue(tt.argument), tt.testDescription)
 	}
 }