Implement a simple, robust and predictable KV parser

commands.go

@@ -339,24 +339,6 @@ func getCommands(ctx context.Context, action *ap.Action, app *cli.App) []cli.Com
 				},
 			},
 		},
-		{
-			Name:   "fix",
-			Usage:  "Upgrade secrets",
-			Before: func(c *cli.Context) error { return action.Initialized(withGlobalFlags(ctx, c), c) },
-			Action: func(c *cli.Context) error {
-				return action.Fix(withGlobalFlags(ctx, c), c)
-			},
-			Flags: []cli.Flag{
-				cli.BoolFlag{
-					Name:  "check, c",
-					Usage: "Only report",
-				},
-				cli.BoolFlag{
-					Name:  "force, f",
-					Usage: "Auto-correct any errors, do not ask",
-				},
-			},
-		},
 		{
 			Name:  "generate",
 			Usage: "Generate a new password",

commands_test.go

@@ -89,7 +89,7 @@ func TestGetCommands(t *testing.T) {
 	c := cli.NewContext(app, fs, nil)
 
 	commands := getCommands(ctx, act, app)
-	assert.Equal(t, 31, len(commands))
+	assert.Equal(t, 30, len(commands))
 
 	prefix := ""
 	testCommands(t, c, commands, prefix)

store/secret/kv.go

@@ -0,0 +1,93 @@
+package secret
+
+import (
+	"bufio"
+	"fmt"
+	"sort"
+	"strings"
+)
+
+func (s *Secret) decodeKV() error {
+	mayBeYAML := false
+	scanner := bufio.NewScanner(strings.NewReader(s.body))
+	data := make(map[string]interface{}, strings.Count(s.body, "\n"))
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "---") {
+			mayBeYAML = true
+		}
+		parts := strings.SplitN(line, ":", 2)
+		if len(parts) < 1 {
+			continue
+		}
+		if len(parts) == 1 && strings.HasPrefix(parts[0], "  ") {
+			mayBeYAML = true
+		}
+		for i, part := range parts {
+			parts[i] = strings.TrimSpace(part)
+		}
+		// preserve key only entries
+		if len(parts) < 2 {
+			data[parts[0]] = ""
+			continue
+		}
+		if strings.HasPrefix(parts[1], "|") {
+			mayBeYAML = true
+		}
+		data[parts[0]] = parts[1]
+	}
+	if mayBeYAML {
+		docSep, err := s.decodeYAML()
+		if debug {
+			fmt.Printf("[DEBUG] decodeKV() - mayBeYAML - err: %s\n", err)
+		}
+		if docSep && err == nil && s.data != nil {
+			return nil
+		}
+	}
+	if debug {
+		fmt.Printf("[DEBUG] decodeKV() - simple KV\n")
+	}
+	s.data = data
+	return nil
+}
+
+func (s *Secret) encodeKV() error {
+	if s.data == nil {
+		return nil
+	}
+	keys := make([]string, 0, len(s.data))
+	for key := range s.data {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	var buf strings.Builder
+	mayBeYAML := false
+	for _, key := range keys {
+		sv, ok := s.data[key].(string)
+		if !ok {
+			mayBeYAML = true
+			continue
+		}
+		_, _ = buf.WriteString(key)
+		_, _ = buf.WriteString(": ")
+		_, _ = buf.WriteString(sv)
+		_, _ = buf.WriteString("\n")
+		if strings.Contains(sv, "\n") {
+			mayBeYAML = true
+		}
+	}
+	if mayBeYAML {
+		if err := s.encodeYAML(); err == nil {
+			if debug {
+				fmt.Printf("[DEBUG] encodeKV() - mayBeYAML - OK\n")
+			}
+			return nil
+		}
+	}
+	if debug {
+		fmt.Printf("[DEBUG] encodeKV() - simple KV\n")
+	}
+	s.body = buf.String()
+	return nil
+}

store/secret/kv_test.go

@@ -0,0 +1,43 @@
+package secret
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestYAMLFromHereDoc(t *testing.T) {
+	t.Logf("Parse K/V w/ HereDoc as YAML, not K/V")
+	mlValue := `somepw
+---
+foo:  |
+  bar
+  baz
+key: value
+`
+	s, err := Parse([]byte(mlValue))
+	assert.NoError(t, err)
+	assert.NotNil(t, s)
+	v, err := s.Value("foo")
+	assert.NoError(t, err)
+	assert.Equal(t, "bar\nbaz\n", v)
+}
+
+func TestKVContentFromInvalidYAML(t *testing.T) {
+	t.Logf("Retrieve content from invalid YAML (#375)")
+	mlValue := `somepasswd
+---
+Test / test.com
+username: [email protected]
+password: somepasswd
+url: http://www.test.com/`
+	s, err := Parse([]byte(mlValue))
+	assert.NoError(t, err)
+	assert.NotNil(t, s)
+	v, err := s.Value("Test / test.com")
+	assert.NoError(t, err)
+	assert.Equal(t, "", v)
+
+	// read back key
+	assert.Equal(t, mlValue, s.String())
+}