Add support for multiple formatters to control output format of render

Signed-off-by: Joffrey F <joffrey@docker.com>

Author: shin-

cmd/docker-app/render.go

@@ -5,8 +5,8 @@ import (
 	"os"
 
 	"github.com/docker/app/internal"
+	"github.com/docker/app/internal/formatter"
 	"github.com/docker/app/internal/packager"
-	"github.com/docker/app/internal/yaml"
 	"github.com/docker/app/render"
 	"github.com/docker/app/types"
 	"github.com/docker/cli/cli"
@@ -16,6 +16,7 @@ import (
 )
 
 var (
+	formatDriver       string
 	renderComposeFiles []string
 	renderSettingsFile []string
 	renderEnv          []string
@@ -42,7 +43,7 @@ func renderCmd(dockerCli command.Cli) *cobra.Command {
 			if err != nil {
 				return err
 			}
-			res, err := yaml.Marshal(rendered)
+			res, err := formatter.Format(rendered, formatDriver)
 			if err != nil {
 				return err
 			}
@@ -68,5 +69,6 @@ func renderCmd(dockerCli command.Cli) *cobra.Command {
 	cmd.Flags().StringArrayVarP(&renderSettingsFile, "settings-files", "f", []string{}, "Override settings files")
 	cmd.Flags().StringArrayVarP(&renderEnv, "set", "s", []string{}, "Override settings values")
 	cmd.Flags().StringVarP(&renderOutput, "output", "o", "-", "Output file")
+	cmd.Flags().StringVarP(&formatDriver, "presenter", "p", "yaml", "Configure the output format")
 	return cmd
 }

internal/formatter/driver/driver.go

@@ -0,0 +1,11 @@
+package driver
+
+import (
+    composetypes "github.com/docker/cli/cli/compose/types"
+)
+
+// Driver is the interface that must be implemented by a formatter driver.
+type Driver interface {
+    // Format executes the formatter on the source config
+    Format(config *composetypes.Config) (string, error)
+}

internal/formatter/formatter.go

@@ -0,0 +1,58 @@
+package formatter
+
+import (
+    "sort"
+    "sync"
+
+    "github.com/docker/app/internal/formatter/driver"
+    composetypes "github.com/docker/cli/cli/compose/types"
+    "github.com/pkg/errors"
+)
+
+var (
+    driversMu sync.RWMutex
+    drivers   = map[string]driver.Driver{}
+)
+
+// Register makes a formatter available by the provided name.
+// If Register is called twice with the same name or if driver is nil,
+// it panics.
+func Register(name string, driver driver.Driver) {
+    driversMu.Lock()
+    defer driversMu.Unlock()
+    if driver == nil {
+        panic("formatter: Register driver is nil")
+    }
+    if _, dup := drivers[name]; dup {
+        panic("formatter: Register called twice for driver " + name)
+    }
+    drivers[name] = driver
+}
+
+// Format uses the specified formatter to create a printable output.
+// If the formatter is not registered, this errors out.
+func Format(config *composetypes.Config, formatter string) (string, error) {
+    driversMu.RLock()
+    d, present := drivers[formatter]
+    driversMu.RUnlock()
+    if !present {
+        return "", errors.Errorf("unknown formatter %s", formatter)
+    }
+    s, err := d.Format(config)
+    if err != nil {
+        return "", err
+    }
+    return s, nil
+}
+
+// Drivers returns a sorted list of the names of the registered drivers.
+func Drivers() []string {
+    list := []string{}
+    driversMu.RLock()
+    for name := range drivers {
+        list = append(list, name)
+    }
+    driversMu.RUnlock()
+    sort.Strings(list)
+    return list
+}

internal/formatter/formatter_test.go

@@ -0,0 +1,96 @@
+package formatter
+
+import (
+    "testing"
+
+    "github.com/docker/app/internal/formatter/driver"
+    composetypes "github.com/docker/cli/cli/compose/types"
+    "github.com/pkg/errors"
+    "gotest.tools/assert"
+    is "gotest.tools/assert/cmp"
+)
+
+type fakeDriver struct{}
+
+func (d *fakeDriver) Format(config *composetypes.Config) (string, error) {
+    return "fake", nil
+}
+
+type fakeErrorDriver struct{}
+
+func (d *fakeErrorDriver) Format(config *composetypes.Config) (string, error) {
+    return "", errors.New("error in driver")
+}
+
+func TestRegisterNilPanics(t *testing.T) {
+    defer func() {
+        if recover() == nil {
+            t.Errorf("The code did not panic")
+        }
+        resetDrivers()
+    }()
+    Register("foo", nil)
+}
+
+func TestRegisterDuplicatePanics(t *testing.T) {
+    defer func() {
+        if recover() == nil {
+            t.Errorf("The code did not panic")
+        }
+        resetDrivers()
+    }()
+    Register("bar", &fakeDriver{})
+    Register("bar", &fakeDriver{})
+}
+
+func TestRegister(t *testing.T) {
+    d := &fakeDriver{}
+    Register("baz", d)
+    defer resetDrivers()
+    assert.Check(t, is.DeepEqual(drivers, map[string]driver.Driver{"baz": d}))
+}
+
+func TestNoDrivers(t *testing.T) {
+    assert.Check(t, is.DeepEqual(Drivers(), []string{}))
+}
+
+func TestRegisteredDrivers(t *testing.T) {
+    Register("foo", &fakeDriver{})
+    Register("bar", &fakeDriver{})
+    defer resetDrivers()
+    assert.Check(t, is.DeepEqual(Drivers(), []string{"bar", "foo"}))
+}
+
+func TestFormatNonExistentDriver(t *testing.T) {
+    _, err := Format(&composetypes.Config{}, "toto")
+    assert.Check(t, err != nil)
+    assert.Check(t, is.ErrorContains(err, "unknown formatter toto"))
+}
+
+func TestFormatErrorDriver(t *testing.T) {
+    Register("err", &fakeErrorDriver{})
+    defer resetDrivers()
+    _, err := Format(&composetypes.Config{}, "err")
+    assert.Check(t, err != nil)
+    assert.Check(t, is.ErrorContains(err, "error in driver"))
+}
+
+func TestFormatNone(t *testing.T) {
+    Register("fake", &fakeDriver{})
+    defer resetDrivers()
+    _, err := Format(&composetypes.Config{}, "none")
+    assert.Check(t, err != nil)
+    assert.Check(t, is.ErrorContains(err, "unknown formatter none"))
+}
+
+func TestFormat(t *testing.T) {
+    Register("fake", &fakeDriver{})
+    defer resetDrivers()
+    s, err := Format(&composetypes.Config{}, "fake")
+    assert.NilError(t, err)
+    assert.Check(t, is.Equal(s, "fake"))
+}
+
+func resetDrivers() {
+    drivers = map[string]driver.Driver{}
+}

internal/formatter/json/doc.go

@@ -0,0 +1 @@
+package json

internal/formatter/json/driver.go

@@ -0,0 +1,25 @@
+package json
+
+import (
+    "encoding/json"
+
+    "github.com/docker/app/internal/formatter"
+    composetypes "github.com/docker/cli/cli/compose/types"
+    "github.com/pkg/errors"
+)
+
+func init() {
+    formatter.Register("json", &Driver{})
+}
+
+// Driver is the json implementation of formatter drivers.
+type Driver struct{}
+
+// Format creates a JSON document from the source config.
+func (d *Driver) Format(config *composetypes.Config) (string, error) {
+    result, err := json.MarshalIndent(config, "", "  ")
+    if err != nil {
+        return "", errors.Wrap(err, "failed to produce json structure")
+    }
+    return string(result) + "\n", nil
+}

internal/formatter/yaml/doc.go

@@ -0,0 +1 @@
+package yaml

internal/formatter/yaml/driver.go

@@ -0,0 +1,24 @@
+package yaml
+
+import (
+    "github.com/docker/app/internal/formatter"
+    "github.com/docker/app/internal/yaml"
+    composetypes "github.com/docker/cli/cli/compose/types"
+    "github.com/pkg/errors"
+)
+
+func init() {
+    formatter.Register("yaml", &Driver{})
+}
+
+// Driver is the yaml implementation of formatter drivers.
+type Driver struct{}
+
+// Format creates a YAML document from the source config.
+func (d *Driver) Format(config *composetypes.Config) (string, error) {
+    result, err := yaml.Marshal(config)
+    if err != nil {
+        return "", errors.Wrap(err, "failed to produce yaml structure")
+    }
+    return string(result), nil
+}

render/render.go

@@ -22,6 +22,11 @@ import (
 	_ "github.com/docker/app/internal/renderer/mustache"
 	// Register yatee renderer
 	_ "github.com/docker/app/internal/renderer/yatee"
+
+	// Register json formatter
+	_ "github.com/docker/app/internal/formatter/json"
+	// Register yaml formatter
+	_ "github.com/docker/app/internal/formatter/yaml"
 )
 
 var (