From 10029420a52a4a193c4d70b5745cd8d1a77957df Mon Sep 17 00:00:00 2001 From: Mike Farah Date: Fri, 28 Feb 2020 11:30:16 +1100 Subject: [PATCH] wip --- cmd/commands_test.go | 151 +++++++++++++++++++++++++++++++++++++++++++ cmd/constant.go | 1 + cmd/read.go | 1 + cmd/utils.go | 13 ++++ 4 files changed, 166 insertions(+) diff --git a/cmd/commands_test.go b/cmd/commands_test.go index d7d7b0b..fd1f5b1 100644 --- a/cmd/commands_test.go +++ b/cmd/commands_test.go @@ -190,6 +190,157 @@ func TestReadArrayCmd(t *testing.T) { test.AssertResult(t, "b.e.[1].name: sam\n", result.Output) } +func TestReadArrayLengthCmd(t *testing.T) { + content := `- things +- whatever +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "2\n", result.Output) +} + +func TestReadArrayLengthDeepCmd(t *testing.T) { + content := `holder: +- things +- whatever +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s holder", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "2\n", result.Output) +} + +func TestReadArrayLengthDeepMultipleCmd(t *testing.T) { + content := `holderA: +- things +- whatever +holderB: +- other things +- cool +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s holder*", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "4\n", result.Output) +} + +func TestReadArrayLengthDeepMultipleWithPathCmd(t *testing.T) { + content := `holderA: +- things +- whatever +holderB: +- other things +- cool +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s -ppv holder*", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "holderA: 2\nholderB: 2", result.Output) +} + +func TestReadObjectLengthCmd(t *testing.T) { + content := `cat: meow +dog: bark +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "2\n", result.Output) +} + +func TestReadObjectLengthDeepCmd(t *testing.T) { + content := `holder: + cat: meow + dog: bark +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s holder", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "2\n", result.Output) +} + +func TestReadObjectLengthDeepMultipleCmd(t *testing.T) { + content := `holderA: + cat: meow + dog: bark +holderB: + elephant: meow + zebra: bark +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s holder*", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "4\n", result.Output) +} + +func TestReadObjectLengthDeepMultipleWithPathsCmd(t *testing.T) { + content := `holderA: + cat: meow + dog: bark +holderB: + elephant: meow + zebra: bark +` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l -ppv %s holder*", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "holderA: 2\nholderB: 2\n", result.Output) +} + +func TestReadScalarLengthCmd(t *testing.T) { + content := `meow` + filename := test.WriteTempYamlFile(content) + defer test.RemoveTempYamlFile(filename) + + cmd := getRootCommand() + result := test.RunCmd(cmd, fmt.Sprintf("read -l %s", filename)) + if result.Error != nil { + t.Error(result.Error) + } + test.AssertResult(t, "2\n", result.Output) +} + func TestReadDeepSplatCmd(t *testing.T) { cmd := getRootCommand() result := test.RunCmd(cmd, "read -p pv ../examples/sample.yaml b.**") diff --git a/cmd/constant.go b/cmd/constant.go index eef26cf..b54500b 100644 --- a/cmd/constant.go +++ b/cmd/constant.go @@ -7,6 +7,7 @@ import ( var customTag = "" var printMode = "v" +var printLength = false var writeInplace = false var writeScript = "" var sourceYamlFile = "" diff --git a/cmd/read.go b/cmd/read.go index 4a30faa..d94b85e 100644 --- a/cmd/read.go +++ b/cmd/read.go @@ -26,6 +26,7 @@ yq r -- things.yaml '--key-starting-with-dashes.blah' cmdRead.PersistentFlags().StringVarP(&docIndex, "doc", "d", "0", "process document index number (0 based, * for all documents)") cmdRead.PersistentFlags().StringVarP(&printMode, "printMode", "p", "v", "print mode (v (values, default), p (paths), pv (path and value pairs)") cmdRead.PersistentFlags().StringVarP(&defaultValue, "defaultValue", "D", "", "default value printed when there are no results") + cmdRead.PersistentFlags().BoolVarP(&printLength, "length", "l", false, "print length of results") cmdRead.PersistentFlags().BoolVarP(&explodeAnchors, "explodeAnchors", "X", false, "explode anchors") return cmdRead } diff --git a/cmd/utils.go b/cmd/utils.go index 93a674a..16acca5 100644 --- a/cmd/utils.go +++ b/cmd/utils.go @@ -128,6 +128,19 @@ func explode(matchingNodes []*yqlib.NodeContext) error { return nil } +func convertToLength(node *yaml.Node) *yaml.Node { + + switch kindToCheck { + case yaml.ScalarNode: + return len(node.Value) + case yaml.MappingNode: + return len(node.Content) / 2 + default: + return len(node.Content) + } + +} + func printResults(matchingNodes []*yqlib.NodeContext, writer io.Writer) error { if prettyPrint { setStyle(matchingNodes, 0)