emitter: add indentless_block_sequence option (#13)

* emitter: add indentless_block_sequence option

Add an option that will force block sequence items not to be indented.

* add formatting test suites

apic.go

@@ -196,10 +196,16 @@ func yaml_emitter_set_explicit_document_start(emitter *yaml_emitter_t, document_
 	emitter.explicit_document_start = document_start
 }
 
+// Set assume folded as literal.
 func yaml_emitter_set_assume_folded_as_literal(emitter *yaml_emitter_t, folded_as_literal bool) {
 	emitter.assume_folded_as_literal = folded_as_literal
 }
 
+// Set indentless block sequence.
+func yaml_emitter_set_indentless_block_sequence(emitter *yaml_emitter_t, indentless_block_sequence bool) {
+	emitter.indentless_block_sequence = indentless_block_sequence
+}
+
 ///*
 // * Destroy a token object.
 // */

emitterc.go

@@ -236,7 +236,6 @@ func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool
 	} else if !indentless {
 		// [Go] This was changed so that indentations are more regular.
 		if emitter.states[len(emitter.states)-1] == yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE {
-			// The first indent inside a sequence will just skip the "- " indicator.
 			emitter.indent += 2
 		} else {
 			// Everything else aligns to the chosen indentation.
@@ -727,7 +726,7 @@ func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_e
 // Expect a block item node.
 func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
 	if first {
-		if !yaml_emitter_increase_indent(emitter, false, false) {
+		if !yaml_emitter_increase_indent(emitter, false, emitter.indentless_block_sequence) {
 			return false
 		}
 	}

formattest/README.md

@@ -0,0 +1,3 @@
+# Format Tests
+
+This is where I will write any formatting tests that mess with decoding and immediately encoding a document.

formattest/encode_test.go

@@ -0,0 +1,53 @@
+package formattest
+
+import (
+	"testing"
+
+	"github.com/braydonk/yaml"
+)
+
+func TestExplicitDocumentStart(t *testing.T) {
+	formatTestCase{
+		name:             "explicit document start",
+		folder:           "document_start",
+		configureDecoder: noopDecoder,
+		configureEncoder: func(enc *yaml.Encoder) {
+			enc.SetExplicitDocumentStart(true)
+		},
+	}.Run(t)
+}
+
+func TestIndentless(t *testing.T) {
+	formatTestCase{
+		name:             "indentless array",
+		folder:           "indentless",
+		configureDecoder: noopDecoder,
+		configureEncoder: func(enc *yaml.Encoder) {
+			enc.SetIndentlessBlockSequence(true)
+		},
+	}.Run(t)
+}
+
+func TestIndentedToIndentless(t *testing.T) {
+	formatTestCase{
+		name:             "indented to indentless array",
+		folder:           "indented_to_indentless",
+		configureDecoder: noopDecoder,
+		configureEncoder: func(enc *yaml.Encoder) {
+			enc.SetIndentlessBlockSequence(true)
+		},
+	}.Run(t)
+}
+
+func TestBlockScalar(t *testing.T) {
+	formatTestCase{
+		name:   "block scalar decoding and encoding",
+		folder: "block_scalar",
+		configureDecoder: func(dec *yaml.Decoder) {
+			dec.SetScanBlockScalarAsLiteral(true)
+		},
+		configureEncoder: func(enc *yaml.Encoder) {
+			enc.SetAssumeBlockAsLiteral(true)
+		},
+	}.Run(t)
+}

formattest/testcase.go

@@ -0,0 +1,77 @@
+package formattest
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/braydonk/yaml"
+)
+
+type decoderConfigureFunc func(*yaml.Decoder)
+
+func noopDecoder(dec *yaml.Decoder) {}
+
+type encoderConfigureFunc func(*yaml.Encoder)
+
+type formatTestCase struct {
+	name             string
+	folder           string
+	configureDecoder decoderConfigureFunc
+	configureEncoder encoderConfigureFunc
+}
+
+func (tc formatTestCase) Run(t *testing.T) {
+	t.Run(tc.name, func(t *testing.T) {
+		// Read test input
+		input, err := tc.readTestdataFile("input.yaml")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// Configure Decoder
+		reader := bytes.NewReader(input)
+		decoder := yaml.NewDecoder(reader)
+		tc.configureDecoder(decoder)
+
+		// Decode input document
+		var n yaml.Node
+		err = decoder.Decode(&n)
+		if err != nil && !errors.Is(err, io.EOF) {
+			t.Fatalf("expect EOF, got:\n%v", err)
+		}
+
+		// Configure Encoder
+		var buf bytes.Buffer
+		enc := yaml.NewEncoder(&buf)
+		tc.configureEncoder(enc)
+
+		// Encode the decoded input document
+		err = enc.Encode(&n)
+		if err != nil {
+			t.Fatalf("expected nil err, got:\n%v", err)
+		}
+
+		// Read the expected output
+		expected, err := tc.readTestdataFile("expected.yaml")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if buf.String() != string(expected) {
+			t.Fatalf("expected:\n%s\nactual:\n%s", string(expected), buf.String())
+		}
+	})
+}
+
+func (tc formatTestCase) readTestdataFile(path string) ([]byte, error) {
+	fullPath := filepath.Join("testdata", tc.folder, path)
+	content, err := os.ReadFile(fullPath)
+	if err != nil {
+		return nil, fmt.Errorf("path %s not found", fullPath)
+	}
+	return content, nil
+}

formattest/testdata/block_scalar/expected.yaml

@@ -0,0 +1,4 @@
+commands: >
+    [ -f "/usr/local/bin/foo" ] &&
+    echo "skip install" ||
+    go install github.com/foo/foo@latest

formattest/testdata/block_scalar/input.yaml

@@ -0,0 +1,4 @@
+commands: >
+    [ -f "/usr/local/bin/foo" ] &&
+    echo "skip install" ||
+    go install github.com/foo/foo@latest

formattest/testdata/document_start/expected.yaml

@@ -0,0 +1,2 @@
+---
+a: 1

formattest/testdata/document_start/input.yaml

@@ -0,0 +1 @@
+a: 1

formattest/testdata/indented_to_indentless/expected.yaml

@@ -0,0 +1,3 @@
+a:
+- 1
+- 2

formattest/testdata/indented_to_indentless/input.yaml

@@ -0,0 +1,3 @@
+a:
+    - 1
+    - 2

formattest/testdata/indentless/expected.yaml

@@ -0,0 +1,7 @@
+a:
+- 1
+- 2
+b:
+    c:
+    - 1
+    - 2

formattest/testdata/indentless/input.yaml

@@ -0,0 +1,7 @@
+a:
+- 1
+- 2
+b:
+    c:
+    - 1
+    - 2

yaml.go

@@ -307,10 +307,17 @@ func (e *Encoder) SetExplicitDocumentStart(documentStart bool) {
 	yaml_emitter_set_explicit_document_start(&e.encoder.emitter, documentStart)
 }
 
+// SetAssumeBlockAsLiteral is a workaround to allow block literals
+// to retain their scanned form in the resulting marshalled document.
 func (e *Encoder) SetAssumeBlockAsLiteral(assumeLiteralBlock bool) {
 	yaml_emitter_set_assume_folded_as_literal(&e.encoder.emitter, assumeLiteralBlock)
 }
 
+// SetIndentlessBlockSequence forces block sequence items not to be indented.
+func (e *Encoder) SetIndentlessBlockSequence(indentlessBlockSequence bool) {
+	yaml_emitter_set_indentless_block_sequence(&e.encoder.emitter, indentlessBlockSequence)
+}
+
 // Close closes the encoder by writing any remaining data.
 // It does not write a stream terminating string "...".
 func (e *Encoder) Close() (err error) {

yamlh.go

@@ -730,13 +730,14 @@ type yaml_emitter_t struct {
 
 	// Emitter stuff
 
-	canonical                bool         // If the output is in the canonical style?
-	best_indent              int          // The number of indentation spaces.
-	best_width               int          // The preferred width of the output lines.
-	unicode                  bool         // Allow unescaped non-ASCII characters?
-	line_break               yaml_break_t // The preferred line break.
-	explicit_document_start  bool         // Force an explicit document start
-	assume_folded_as_literal bool         // Assume blocks were scanned as literals
+	canonical                 bool         // If the output is in the canonical style?
+	best_indent               int          // The number of indentation spaces.
+	best_width                int          // The preferred width of the output lines.
+	unicode                   bool         // Allow unescaped non-ASCII characters?
+	line_break                yaml_break_t // The preferred line break.
+	explicit_document_start   bool         // Force an explicit document start
+	assume_folded_as_literal  bool         // Assume blocks were scanned as literals
+	indentless_block_sequence bool         // Do not indent block sequences
 
 	state  yaml_emitter_state_t   // The current emitter state.
 	states []yaml_emitter_state_t // The stack of states.