big wip

coder · ammario · Apr 7, 2023 · Mar 30, 2023 · Mar 30, 2023 · Mar 30, 2023
commit 0d08b844123f54c47f3fa4114432e59ec7f7398c
diff --git a/cli/clibase/yaml.go b/cli/clibase/yaml.go
@@ -1,6 +1,8 @@
 package clibase
 
 import (
+	"errors"
+
 	"github.com/iancoleman/strcase"
 	"github.com/mitchellh/go-wordwrap"
 	"golang.org/x/xerrors"
@@ -41,6 +43,8 @@ func deepMapNode(n *yaml.Node, path []string, headComment string) *yaml.Node {
 //
 // The node is returned to enable post-processing higher up in
 // the stack.
+//
+// It is isomorphic with FromYAML.
 func (s OptionSet) ToYAML() (*yaml.Node, error) {
 	root := yaml.Node{
 		Kind: yaml.MappingNode,
@@ -103,3 +107,117 @@ func (s OptionSet) ToYAML() (*yaml.Node, error) {
 	}
 	return &root, nil
 }
+
+// FromYAML converts the given YAML node into the option set.
+// It is isomorphic with ToYAML.
+
+func (s *OptionSet) FromYAML(n *yaml.Node) error {
+	return fromYAML(*s, nil, n)
+}
+
+func fromYAML(os OptionSet, ofGroup *Group, n *yaml.Node) error {
+	if n.Kind == yaml.DocumentNode && ofGroup == nil {
+		// The root may be a document node.
+		if len(n.Content) != 1 {
+			return xerrors.Errorf("expected one content node, got %d", len(n.Content))
+		}
+		return fromYAML(os, ofGroup, n.Content[0])
+	}
+
+	if n.Kind != yaml.MappingNode {
+		byt, _ := yaml.Marshal(n)
+		return xerrors.Errorf("expected mapping node, got type %v, contents:\n%v", n.Kind, string(byt))
+	}
+
+	var (
+		subGroupsByName = make(map[string]*Group)
+		optionsByName   = make(map[string]*Option)
+	)
+	for i, opt := range os {
+		if opt.YAML == "" {
+			continue
+		}
+
+		// We only want to process options that are of the identified group,
+		// even if that group is nil.
+		if opt.Group != ofGroup {
+			if opt.Group.Parent == ofGroup {
+				subGroupsByName[opt.Group.Name] = opt.Group
+			}
+			continue
+		}
+
+		if _, ok := optionsByName[opt.YAML]; ok {
+			return xerrors.Errorf("duplicate option name %q", opt.YAML)
+		}
+
+		optionsByName[opt.YAML] = &os[i]
+	}
+
+	for k := range subGroupsByName {
+		if _, ok := optionsByName[k]; !ok {
+			continue
+		}
+		return xerrors.Errorf("there is both an option and a group with name %q", k)
+	}
+
+	var (
+		name string
+		merr error
+	)
+
+	for i, item := range n.Content {
+		if isName := i%2 == 0; isName {
+			if item.Kind != yaml.ScalarNode {
+				return xerrors.Errorf("expected scalar node for name, got %v", item.Kind)
+			}
+			name = item.Value
+			continue
+		}
+
+		switch item.Kind {
+		case yaml.MappingNode:
+			// Item is either a group or an option with a complex object.
+			if opt, ok := optionsByName[name]; ok {
+				unmarshaler, ok := opt.Value.(yaml.Unmarshaler)
+				if !ok {
+					return xerrors.Errorf("complex option %q must support unmarshaling", opt.Name)
+				}
+				err := unmarshaler.UnmarshalYAML(item)
+				if err != nil {
+					merr = errors.Join(merr, xerrors.Errorf("unmarshal %q: %w", opt.Name, err))
+				}
+				continue
+			}
+			if g, ok := subGroupsByName[name]; ok {
+				// Group, recurse.
+				err := fromYAML(os, g, item)
+				if err != nil {
+					merr = errors.Join(merr, xerrors.Errorf("group %q: %w", g.FullName(), err))
+				}
+				continue
+			}
+			merr = errors.Join(merr, xerrors.Errorf("unknown option or subgroup %q", name))
+		case yaml.ScalarNode:
+			opt, ok := optionsByName[name]
+			if !ok {
+				merr = errors.Join(merr, xerrors.Errorf("unknown option %q", name))
+				continue
+			}
+
+			unmarshaler, ok := opt.Value.(yaml.Unmarshaler)
+			if !ok {
+				err := opt.Value.Set(item.Value)
+				merr = errors.Join(merr, xerrors.Errorf("set %q: %w", opt.Name, err))
+				continue
+			}
+			err := unmarshaler.UnmarshalYAML(item)
+			if err != nil {
+				merr = errors.Join(merr, xerrors.Errorf("unmarshal %q: %w", opt.Name, err))
+			}
+		default:
+			return xerrors.Errorf("unexpected kind for value %v", item.Kind)
+		}
+	}
+	return merr
+}
diff --git a/cli/clibase/yaml_test.go b/cli/clibase/yaml_test.go
@@ -3,13 +3,15 @@ package clibase_test
 import (
 	"testing"
 
+	"github.com/spf13/pflag"
 	"github.com/stretchr/testify/require"
+	"golang.org/x/exp/slices"
 	"gopkg.in/yaml.v3"
 
 	"github.com/coder/coder/cli/clibase"
 )
 
-func TestOption_ToYAML(t *testing.T) {
+func TestOptionSet_ToYAML(t *testing.T) {
 	t.Parallel()
 
 	t.Run("RequireKey", func(t *testing.T) {
@@ -55,3 +57,65 @@ func TestOption_ToYAML(t *testing.T) {
 		t.Logf("Raw YAML:\n%s", string(byt))
 	})
 }
+
+func TestOptionSet_YAMLIsomorphism(t *testing.T) {
+	t.Parallel()
+	for _, tc := range []struct {
+		name      string
+		os        clibase.OptionSet
+		zeroValue func() pflag.Value
+	}{
+		{
+			name: "SimpleString",
+			os: clibase.OptionSet{
+				{
+					Name:        "Workspace Name",
+					Default:     "billie",
+					Description: "The workspace's name.",
+					Group:       &clibase.Group{Name: "Names"},
+					YAML:        "workspaceName",
+				},
+			},
+			zeroValue: func() pflag.Value {
+				return clibase.StringOf(new(string))
+			},
+		},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			for i := range tc.os {
+				tc.os[i].Value = tc.zeroValue()
+			}
+			err := tc.os.SetDefaults()
+			require.NoError(t, err)
+
+			y, err := tc.os.ToYAML()
+			require.NoError(t, err)
+
+			toByt, err := yaml.Marshal(y)
+			require.NoError(t, err)
+
+			t.Logf("Raw YAML:\n%s", string(toByt))
+
+			var y2 yaml.Node
+			err = yaml.Unmarshal(toByt, &y2)
+			require.NoError(t, err)
+
+			os2 := slices.Clone(tc.os)
+			for i := range os2 {
+				os2[i].Value = tc.zeroValue()
+			}
+
+			// os2 values should be zeroed whereas tc.os should be
+			// set to defaults.
+			// This makes sure we aren't mixing pointers.
+			require.NotEqual(t, tc.os, os2)
+			err = os2.FromYAML(&y2)
+			require.NoError(t, err)
+
+			require.Equal(t, tc.os, os2)
+		})
+	}
+}
diff --git a/cli/server.go b/cli/server.go
@@ -190,6 +190,10 @@ func (r *RootCmd) Server(newAPI func(context.Context, *coderd.Options) (*coderd.
 				return nil
 			}
 
+			if cfg.Config != "" {
+				cliui.Warnf(inv.Stderr, "YAML support is experimental and offers no compatibility guarantees.")
+			}
+
 			// Print deprecation warnings.
 			for _, opt := range opts {
 				if opt.UseInstead == nil {