parser: Indent TOML tables

Fixes #8850

diff --git a/parser/frontmatter.go b/parser/frontmatter.go
index e7492745e4617f349cd67ae867cf004901aeaa66..79701a0fcd2d22e4a9533fb9c0e09f3612904314 100644 (file)
--- a/parser/frontmatter.go
+++ b/parser/frontmatter.go
@@ -46,7 +46,9 @@ func InterfaceToConfig(in interface{}, format metadecoders.Format, w io.Writer)
                return err
 
        case metadecoders.TOML:
-               return toml.NewEncoder(w).Encode(in)
+               enc := toml.NewEncoder(w)
+               enc.SetIndentTables(true)
+               return enc.Encode(in)
        case metadecoders.JSON:
                b, err := json.MarshalIndent(in, "", "   ")
                if err != nil {

diff --git a/tpl/transform/remarshal_test.go b/tpl/transform/remarshal_test.go
index c34122a2a41697a0f80fda7f53aa7a57c725a14c..2cb4c3a2fe624c219aef1afb99e150a63660f9c1 100644 (file)
--- a/tpl/transform/remarshal_test.go
+++ b/tpl/transform/remarshal_test.go
@@ -30,7 +30,9 @@ func TestRemarshal(t *testing.T) {
        ns := New(newDeps(v))
        c := qt.New(t)
 
-       tomlExample := `title = 'Test Metadata'
+       c.Run("Roundtrip variants", func(c *qt.C) {
+
+               tomlExample := `title = 'Test Metadata'
                
 [[resources]]
   src = '**image-4.png'
@@ -46,7 +48,7 @@ func TestRemarshal(t *testing.T) {
     byline = 'bep'
 `
 
-       yamlExample := `resources:
+               yamlExample := `resources:
 - params:
     byline: picasso
   src: '**image-4.png'
@@ -59,7 +61,7 @@ func TestRemarshal(t *testing.T) {
 title: Test Metadata
 `
 
-       jsonExample := `{
+               jsonExample := `{
    "resources": [
       {
          "params": {
@@ -81,44 +83,37 @@ title: Test Metadata
 }
 `
 
-       variants := []struct {
-               format string
-               data   string
-       }{
-               {"yaml", yamlExample},
-               {"json", jsonExample},
-               {"toml", tomlExample},
-               {"TOML", tomlExample},
-               {"Toml", tomlExample},
-               {" TOML ", tomlExample},
-       }
-
-       for _, v1 := range variants {
-               for _, v2 := range variants {
-                       // Both from and to may be the same here, but that is fine.
-                       fromTo := qt.Commentf("%s => %s", v2.format, v1.format)
-
-                       converted, err := ns.Remarshal(v1.format, v2.data)
-                       c.Assert(err, qt.IsNil, fromTo)
-                       diff := htesting.DiffStrings(v1.data, converted)
-                       if len(diff) > 0 {
-                               t.Errorf("[%s] Expected \n%v\ngot\n%v\ndiff:\n%v", fromTo, v1.data, converted, diff)
-                       }
-
+               variants := []struct {
+                       format string
+                       data   string
+               }{
+                       {"yaml", yamlExample},
+                       {"json", jsonExample},
+                       {"toml", tomlExample},
+                       {"TOML", tomlExample},
+                       {"Toml", tomlExample},
+                       {" TOML ", tomlExample},
                }
-       }
-}
 
-func TestRemarshalComments(t *testing.T) {
-       t.Parallel()
+               for _, v1 := range variants {
+                       for _, v2 := range variants {
+                               // Both from and to may be the same here, but that is fine.
+                               fromTo := qt.Commentf("%s => %s", v2.format, v1.format)
 
-       v := config.New()
-       v.Set("contentDir", "content")
-       ns := New(newDeps(v))
+                               converted, err := ns.Remarshal(v1.format, v2.data)
+                               c.Assert(err, qt.IsNil, fromTo)
+                               diff := htesting.DiffStrings(v1.data, converted)
+                               if len(diff) > 0 {
+                                       t.Errorf("[%s] Expected \n%v\ngot\n%v\ndiff:\n%v", fromTo, v1.data, converted, diff)
+                               }
 
-       c := qt.New(t)
+                       }
+               }
+
+       })
 
-       input := `
+       c.Run("Comments", func(c *qt.C) {
+               input := `
 Hugo = "Rules"
                
 # It really does!
@@ -129,56 +124,59 @@ a = "b"
 
 `
 
-       expected := `Hugo = 'Rules'
+               expected := `Hugo = 'Rules'
 [m]
 a = 'b'
 `
 
-       for _, format := range []string{"json", "yaml", "toml"} {
-               fromTo := qt.Commentf("%s => %s", "toml", format)
+               for _, format := range []string{"json", "yaml", "toml"} {
+                       fromTo := qt.Commentf("%s => %s", "toml", format)
 
-               converted := input
-               var err error
-               // Do a round-trip conversion
-               for _, toFormat := range []string{format, "toml"} {
-                       converted, err = ns.Remarshal(toFormat, converted)
-                       c.Assert(err, qt.IsNil, fromTo)
-               }
+                       converted := input
+                       var err error
+                       // Do a round-trip conversion
+                       for _, toFormat := range []string{format, "toml"} {
+                               converted, err = ns.Remarshal(toFormat, converted)
+                               c.Assert(err, qt.IsNil, fromTo)
+                       }
 
-               diff := htesting.DiffStrings(expected, converted)
-               if len(diff) > 0 {
-                       t.Fatalf("[%s] Expected \n%v\ngot\n>>%v\ndiff:\n%v\n", fromTo, expected, converted, diff)
+                       diff := htesting.DiffStrings(expected, converted)
+                       if len(diff) > 0 {
+                               t.Fatalf("[%s] Expected \n%v\ngot\n>>%v\ndiff:\n%v\n", fromTo, expected, converted, diff)
+                       }
                }
-       }
-}
+       })
 
-func TestTestRemarshalError(t *testing.T) {
-       t.Parallel()
-       c := qt.New(t)
+       // Issue 8850
+       c.Run("TOML Indent", func(c *qt.C) {
+               input := `
 
-       v := config.New()
-       v.Set("contentDir", "content")
-       ns := New(newDeps(v))
+[params]
+[params.variables]
+a = "b"
+
+`
 
-       _, err := ns.Remarshal("asdf", "asdf")
-       c.Assert(err, qt.Not(qt.IsNil))
+               converted, err := ns.Remarshal("toml", input)
+               c.Assert(err, qt.IsNil)
+               c.Assert(converted, qt.Equals, "[params]\n  [params.variables]\n    a = 'b'\n\n\n")
+       })
 
-       _, err = ns.Remarshal("json", "asdf")
-       c.Assert(err, qt.Not(qt.IsNil))
-}
+       c.Run("Map input", func(c *qt.C) {
+               input := map[string]interface{}{
+                       "hello": "world",
+               }
 
-func TestTestRemarshalMapInput(t *testing.T) {
-       t.Parallel()
-       c := qt.New(t)
-       v := config.New()
-       v.Set("contentDir", "content")
-       ns := New(newDeps(v))
+               output, err := ns.Remarshal("toml", input)
+               c.Assert(err, qt.IsNil)
+               c.Assert(output, qt.Equals, "hello = 'world'\n")
+       })
 
-       input := map[string]interface{}{
-               "hello": "world",
-       }
+       c.Run("Error", func(c *qt.C) {
+               _, err := ns.Remarshal("asdf", "asdf")
+               c.Assert(err, qt.Not(qt.IsNil))
 
-       output, err := ns.Remarshal("toml", input)
-       c.Assert(err, qt.IsNil)
-       c.Assert(output, qt.Equals, "hello = 'world'\n")
+               _, err = ns.Remarshal("json", "asdf")
+               c.Assert(err, qt.Not(qt.IsNil))
+       })
 }