cmd/export: emit comments by default

Signed-off-by: Felix Geisendörfer <[email protected]>

cmd/cue/cmd/common.go

@@ -719,15 +719,14 @@ func (b *buildPlan) parseFlags() (err error) {
 		b.cfg.fileFilter = s
 	}
 	b.encConfig = &encoding.Config{
-		Force:            flagForce.Bool(b.cmd),
-		Mode:             b.cfg.outMode,
-		Stdin:            b.cmd.InOrStdin(),
-		Stdout:           b.cmd.OutOrStdout(),
-		ProtoPath:        flagProtoPath.StringArray(b.cmd),
-		AllErrors:        flagAllErrors.Bool(b.cmd),
-		PkgName:          flagPackage.String(b.cmd),
-		Strict:           flagStrict.Bool(b.cmd),
-		PreserveComments: flagPreserveComments.Bool(b.cmd),
+		Force:     flagForce.Bool(b.cmd),
+		Mode:      b.cfg.outMode,
+		Stdin:     b.cmd.InOrStdin(),
+		Stdout:    b.cmd.OutOrStdout(),
+		ProtoPath: flagProtoPath.StringArray(b.cmd),
+		AllErrors: flagAllErrors.Bool(b.cmd),
+		PkgName:   flagPackage.String(b.cmd),
+		Strict:    flagStrict.Bool(b.cmd),
 	}
 	return nil
 }

cmd/cue/cmd/export.go

@@ -96,7 +96,6 @@ yaml    output as YAML
 	addOrphanFlags(cmd.Flags())
 	addInjectionFlags(cmd.Flags(), false)
 
-	cmd.Flags().Bool(string(flagPreserveComments), false, "include comments in output")
 	cmd.Flags().Bool(string(flagEscape), false, "use HTML escaping")
 	cmd.Flags().StringArrayP(string(flagExpression), "e", nil, "export this expression only")
 

cmd/cue/cmd/flags.go

@@ -21,19 +21,18 @@ import (
 
 // Common flags
 const (
-	flagAll              flagName = "all"
-	flagDryrun           flagName = "dryrun"
-	flagVerbose          flagName = "verbose"
-	flagAllErrors        flagName = "all-errors"
-	flagTrace            flagName = "trace"
-	flagForce            flagName = "force"
-	flagIgnore           flagName = "ignore"
-	flagStrict           flagName = "strict"
-	flagSimplify         flagName = "simplify"
-	flagPackage          flagName = "package"
-	flagInject           flagName = "inject"
-	flagInjectVars       flagName = "inject-vars"
-	flagPreserveComments flagName = "preserve-comments"
+	flagAll        flagName = "all"
+	flagDryrun     flagName = "dryrun"
+	flagVerbose    flagName = "verbose"
+	flagAllErrors  flagName = "all-errors"
+	flagTrace      flagName = "trace"
+	flagForce      flagName = "force"
+	flagIgnore     flagName = "ignore"
+	flagStrict     flagName = "strict"
+	flagSimplify   flagName = "simplify"
+	flagPackage    flagName = "package"
+	flagInject     flagName = "inject"
+	flagInjectVars flagName = "inject-vars"
 
 	flagExpression  flagName = "expression"
 	flagSchema      flagName = "schema"

cmd/cue/cmd/testdata/script/export_yaml_comments.txt

@@ -1,4 +1,4 @@
-cue export --preserve-comments --out yaml ./hello
+cue export --out yaml ./hello
 cmp stdout expect-stdout
 -- expect-stdout --
 # cloud-config

cue/types.go

@@ -2132,7 +2132,7 @@ func All() Option {
 
 // Docs indicates whether docs should be included.
 func Docs(include bool) Option {
-	return func(p *options) { p.docs = true }
+	return func(p *options) { p.docs = include }
 }
 
 // Definitions indicates whether definitions should be included.

internal/encoding/encoder.go

@@ -182,7 +182,7 @@ func NewEncoder(f *build.File, cfg *Config) (*Encoder, error) {
 			}
 			streamed = true
 
-			str, err := yaml.Marshal(v, cue.Docs(e.cfg.PreserveComments))
+			str, err := yaml.Marshal(v)
 			if err != nil {
 				return err
 			}

internal/encoding/encoding.go

@@ -151,11 +151,10 @@ type Config struct {
 
 	PkgName string // package name for files to generate
 
-	Force            bool // overwrite existing files.
-	Strict           bool
-	Stream           bool // will potentially write more than one document per file
-	AllErrors        bool
-	PreserveComments bool
+	Force     bool // overwrite existing files.
+	Strict    bool
+	Stream    bool // will potentially write more than one document per file
+	AllErrors bool
 
 	Schema cue.Value // used for schema-based decoding
 

pkg/encoding/yaml/manual.go

@@ -26,7 +26,7 @@ import (
 )
 
 // Marshal returns the YAML encoding of v.
-func Marshal(v cue.Value, opts ...cue.Option) (string, error) {
+func Marshal(v cue.Value) (string, error) {
 	if err := v.Validate(cue.Concrete(true)); err != nil {
 		if err := v.Validate(); err != nil {
 			return "", err
@@ -35,14 +35,13 @@ func Marshal(v cue.Value, opts ...cue.Option) (string, error) {
 		// messages can be passed.
 		return "", internal.ErrIncomplete
 	}
-	opts = append([]cue.Option{cue.Final(), cue.Concrete(true)}, opts...)
-	n := v.Syntax(opts...)
+	n := v.Syntax(cue.Final(), cue.Concrete(true), cue.Docs(true))
 	b, err := cueyaml.Encode(n)
 	return string(b), err
 }
 
 // MarshalStream returns the YAML encoding of v.
-func MarshalStream(v cue.Value, opts ...cue.Option) (string, error) {
+func MarshalStream(v cue.Value) (string, error) {
 	// TODO: return an io.Reader and allow asynchronous processing.
 	iter, err := v.List()
 	if err != nil {
@@ -54,16 +53,15 @@ func MarshalStream(v cue.Value, opts ...cue.Option) (string, error) {
 			buf.WriteString("---\n")
 		}
 		v := iter.Value()
-		if err := v.Validate(cue.Concrete(true)); err != nil {
+		if err := v.Validate(cue.Concrete(true), cue.Docs(true)); err != nil {
 			if err := v.Validate(); err != nil {
 				return "", err
 			}
 			// TODO: allow adt.Bottom to implement errors.Error so that code and
 			// messages can be passed.
 			return "", internal.ErrIncomplete
 		}
-		opts = append([]cue.Option{cue.Final(), cue.Concrete(true)}, opts...)
-		n := v.Syntax(opts...)
+		n := v.Syntax(cue.Final(), cue.Concrete(true))
 		b, err := cueyaml.Encode(n)
 		if err != nil {
 			return "", err