revert WriteDir to use JSON, but keep WriteYAML support

Signed-off-by: Joe Lanford <[email protected]>

Author: joelanford

internal/declcfg/write.go

@@ -8,7 +8,9 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"sort"
 
+	"k8s.io/apimachinery/pkg/util/sets"
 	"sigs.k8s.io/yaml"
 
 	"github.com/operator-framework/operator-registry/internal/property"
@@ -75,7 +77,7 @@ func writeToFS(cfg DeclarativeConfig, w fsWriter, rootDir string) error {
 		if err := w.MkdirAll(pkgDir, 0777); err != nil {
 			return err
 		}
-		filename := filepath.Join(pkgDir, fmt.Sprintf("%s.yaml", p.Name))
+		filename := filepath.Join(pkgDir, fmt.Sprintf("%s.json", p.Name))
 		if err := writeFile(fcfg, w, filename); err != nil {
 			return err
 		}
@@ -91,7 +93,7 @@ func writeToFS(cfg DeclarativeConfig, w fsWriter, rootDir string) error {
 		gcfg := DeclarativeConfig{
 			Others: globals,
 		}
-		filename := filepath.Join(rootDir, fmt.Sprintf("%s.yaml", globalName))
+		filename := filepath.Join(rootDir, fmt.Sprintf("%s.json", globalName))
 		if err := writeFile(gcfg, w, filename); err != nil {
 			return err
 		}
@@ -124,7 +126,7 @@ func writeObjectFiles(b Bundle, w fsWriter, baseDir string) error {
 
 func writeFile(cfg DeclarativeConfig, w fsWriter, filename string) error {
 	buf := &bytes.Buffer{}
-	if err := writeYAML(cfg, buf); err != nil {
+	if err := WriteJSON(cfg, buf); err != nil {
 		return fmt.Errorf("write to buffer for %q: %v", filename, err)
 	}
 	if err := w.WriteFile(filename, buf.Bytes(), 0666); err != nil {
@@ -133,42 +135,28 @@ func writeFile(cfg DeclarativeConfig, w fsWriter, filename string) error {
 	return nil
 }
 
-func writeYAML(cfg DeclarativeConfig, w io.Writer) error {
-	enc := newEncoder(w)
-
-	bundlesByPackage := map[string][]Bundle{}
-	for _, b := range cfg.Bundles {
-		pkgName := b.Package
-		bundlesByPackage[pkgName] = append(bundlesByPackage[pkgName], b)
-	}
+func WriteJSON(cfg DeclarativeConfig, w io.Writer) error {
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "    ")
+	enc.SetEscapeHTML(false)
+	return writeToEncoder(cfg, enc)
+}
 
-	for _, p := range cfg.Packages {
-		if err := enc.Encode(p); err != nil {
-			return err
-		}
-		for _, b := range bundlesByPackage[p.Name] {
-			if err := enc.Encode(b); err != nil {
-				return err
-			}
-		}
-	}
-	for _, o := range cfg.Others {
-		if err := enc.Encode(o); err != nil {
-			return err
-		}
-	}
-	return nil
+func WriteYAML(cfg DeclarativeConfig, w io.Writer) error {
+	enc := newYAMLEncoder(w)
+	return writeToEncoder(cfg, enc)
 }
 
-type encoder struct {
-	w io.Writer
+type yamlEncoder struct {
+	encodedFirst bool
+	w            io.Writer
 }
 
-func newEncoder(w io.Writer) encoder {
-	return encoder{w}
+func newYAMLEncoder(w io.Writer) *yamlEncoder {
+	return &yamlEncoder{false, w}
 }
 
-func (e encoder) Encode(v interface{}) error {
+func (e *yamlEncoder) Encode(v interface{}) error {
 	var buf bytes.Buffer
 	enc := json.NewEncoder(&buf)
 	enc.SetEscapeHTML(false)
@@ -179,7 +167,79 @@ func (e encoder) Encode(v interface{}) error {
 	if err != nil {
 		return err
 	}
-	yamlData = append([]byte("---\n"), yamlData...)
+	if e.encodedFirst {
+		yamlData = append([]byte("---\n"), yamlData...)
+	}
+	e.encodedFirst = true
 	_, err = e.w.Write(yamlData)
 	return err
 }
+
+type encoder interface {
+	Encode(interface{}) error
+}
+
+func writeToEncoder(cfg DeclarativeConfig, enc encoder) error {
+	pkgNames := sets.NewString()
+
+	packagesByName := map[string][]Package{}
+	for _, p := range cfg.Packages {
+		pkgName := p.Name
+		pkgNames.Insert(pkgName)
+		packagesByName[pkgName] = append(packagesByName[pkgName], p)
+	}
+	bundlesByPackage := map[string][]Bundle{}
+	for _, b := range cfg.Bundles {
+		pkgName := b.Package
+		pkgNames.Insert(pkgName)
+		bundlesByPackage[pkgName] = append(bundlesByPackage[pkgName], b)
+	}
+	othersByPackage := map[string][]Meta{}
+	for _, o := range cfg.Others {
+		pkgName := o.Package
+		if pkgName == "" {
+			pkgName = globalName
+		}
+		pkgNames.Insert(pkgName)
+		othersByPackage[pkgName] = append(othersByPackage[pkgName], o)
+	}
+
+	for _, pName := range pkgNames.List() {
+		if pName == globalName {
+			continue
+		}
+		pkgs := packagesByName[pName]
+		for _, p := range pkgs {
+			if err := enc.Encode(p); err != nil {
+				return err
+			}
+		}
+
+		bundles := bundlesByPackage[pName]
+		sort.Slice(bundles, func(i, j int) bool {
+			return bundles[i].Name < bundles[j].Name
+		})
+		for _, b := range bundles {
+			if err := enc.Encode(b); err != nil {
+				return err
+			}
+		}
+
+		others := othersByPackage[pName]
+		sort.SliceStable(others, func(i, j int) bool {
+			return others[i].Schema < others[j].Schema
+		})
+		for _, o := range others {
+			if err := enc.Encode(o); err != nil {
+				return err
+			}
+		}
+	}
+
+	for _, o := range othersByPackage[globalName] {
+		if err := enc.Encode(o); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/declcfg/write_test.go

@@ -89,13 +89,13 @@ func TestWriteDir(t *testing.T) {
 				}
 
 				expectedEntryNames := []string{
-					fmt.Sprintf("%s.yaml", globalName),
+					fmt.Sprintf("%s.json", globalName),
 					"anakin",
 					"boba-fett",
 				}
 				require.ElementsMatch(t, expectedEntryNames, entryNames)
 
-				anakinFilename := filepath.Join(testDir, "anakin", "anakin.yaml")
+				anakinFilename := filepath.Join(testDir, "anakin", "anakin.json")
 				anakinFile, err := os.Open(anakinFilename)
 				require.NoError(t, err)
 				defer anakinFile.Close()
@@ -105,7 +105,7 @@ func TestWriteDir(t *testing.T) {
 				assert.Len(t, anakin.Bundles, 3)
 				assert.Len(t, anakin.Others, 1)
 
-				bobaFettFilename := filepath.Join(testDir, "boba-fett", "boba-fett.yaml")
+				bobaFettFilename := filepath.Join(testDir, "boba-fett", "boba-fett.json")
 				bobaFettFile, err := os.Open(bobaFettFilename)
 				require.NoError(t, err)
 				defer bobaFettFile.Close()
@@ -115,7 +115,7 @@ func TestWriteDir(t *testing.T) {
 				assert.Len(t, bobaFett.Bundles, 2)
 				assert.Len(t, bobaFett.Others, 1)
 
-				globalFilename := filepath.Join(testDir, fmt.Sprintf("%s.yaml", globalName))
+				globalFilename := filepath.Join(testDir, fmt.Sprintf("%s.json", globalName))
 				globalFile, err := os.Open(globalFilename)
 				require.NoError(t, err)
 				globals, err := readYAMLOrJSON(globalFile)