Fix line ending bug

lib/src/editor.dart

@@ -241,11 +241,26 @@ class YamlEditor {
 
     if (path.isEmpty) {
       final start = _contents.span.start.offset;
-      final end = getContentSensitiveEnd(_contents);
+      var end = getContentSensitiveEnd(_contents);
       final lineEnding = getLineEnding(_yaml);
-      final edit = SourceEdit(
-          start, end - start, yamlEncodeBlock(valueNode, 0, lineEnding));
 
+      end = skipAndExtractCommentsInBlock(
+        _yaml,
+        endOfNodeOffset: end,
+        lineEnding: lineEnding,
+        greedy: true,
+      ).endOffset;
+
+      var encoded = yamlEncodeBlock(valueNode, 0, lineEnding);
+      encoded = normalizeEncodedBlock(
+        _yaml,
+        lineEnding: lineEnding,
+        nodeToReplaceEndOffset: end,
+        update: valueNode,
+        updateAsString: encoded,
+        skipPreservationCheck: true,
+      );
+      final edit = SourceEdit(start, end - start, encoded);
       return _performEdit(edit, path, valueNode);
     }
 
@@ -483,7 +498,7 @@ class YamlEditor {
         if (!containsKey(map, keyOrIndex)) {
           return _pathErrorOrElse(path, path.take(i + 1), map, orElse);
         }
-        final keyNode = getKeyNode(map, keyOrIndex);
+        final (_, keyNode) = getKeyNode(map, keyOrIndex);
 
         if (checkAlias) {
           if (_aliases.contains(keyNode)) throw AliasException(path, keyNode);

lib/src/equality.dart

@@ -87,8 +87,10 @@ int deepHashCode(Object? value) {
 }
 
 /// Returns the [YamlNode] corresponding to the provided [key].
-YamlNode getKeyNode(YamlMap map, Object? key) {
-  return map.nodes.keys.firstWhere((node) => deepEquals(node, key)) as YamlNode;
+(int index, YamlNode keyNode) getKeyNode(YamlMap map, Object? key) {
+  return map.nodes.keys.indexed.firstWhere(
+    (value) => deepEquals(value.$2, key),
+  ) as (int, YamlNode);
 }
 
 /// Returns the [YamlNode] after the [YamlNode] corresponding to the provided

lib/src/list_mutations.dart

@@ -29,18 +29,21 @@ SourceEdit updateInList(
     final listIndentation = getListIndentation(yaml, list);
     final indentation = listIndentation + getIndentation(yamlEdit);
     final lineEnding = getLineEnding(yaml);
-    valueString =
-        yamlEncodeBlock(wrapAsYamlNode(newValue), indentation, lineEnding);
+
+    final encoded = yamlEncodeBlock(
+      wrapAsYamlNode(newValue),
+      indentation,
+      lineEnding,
+    );
+    valueString = encoded;
 
     /// We prefer the compact nested notation for collections.
     ///
-    /// By virtue of [yamlEncodeBlockString], collections automatically
+    /// By virtue of [yamlEncodeBlock], collections automatically
     /// have the necessary line endings.
     if ((newValue is List && (newValue as List).isNotEmpty) ||
         (newValue is Map && (newValue as Map).isNotEmpty)) {
       valueString = valueString.substring(indentation);
-    } else if (currValue.collectionStyle == CollectionStyle.BLOCK) {
-      valueString += lineEnding;
     }
 
     var end = getContentSensitiveEnd(currValue);
@@ -50,6 +53,21 @@ SourceEdit updateInList(
       valueString = ' $valueString';
     }
 
+    // Aggressively skip all comments
+    end = skipAndExtractCommentsInBlock(
+      yaml,
+      endOfNodeOffset: end,
+      lineEnding: lineEnding,
+    ).endOffset;
+
+    valueString = normalizeEncodedBlock(
+      yaml,
+      lineEnding: lineEnding,
+      nodeToReplaceEndOffset: end,
+      update: newValue,
+      updateAsString: valueString,
+    );
+
     return SourceEdit(offset, end - offset, valueString);
   } else {
     valueString = yamlEncodeFlow(newValue);
@@ -112,22 +130,41 @@ SourceEdit _appendToFlowList(
 /// block list.
 SourceEdit _appendToBlockList(
     YamlEditor yamlEdit, YamlList list, YamlNode item) {
-  var (indentSize, valueToIndent) = _formatNewBlock(yamlEdit, list, item);
-  var formattedValue = '${' ' * indentSize}$valueToIndent';
+  /// A block list can never be empty since a `-` must be seen for it to be a
+  /// valid block sequence.
+  ///
+  /// See description of:
+  /// https://yaml.org/spec/1.2.2/#82-block-collection-styles.
+  assert(
+    list.isNotEmpty,
+    'A YamlList encoded as CollectionStyle.BLOCK must have a value',
+  );
 
   final yaml = yamlEdit.toString();
-  var offset = list.span.end.offset;
+  final lineEnding = getLineEnding(yaml);
 
-  // Adjusts offset to after the trailing newline of the last entry, if it
-  // exists
-  if (list.isNotEmpty) {
-    final lastValueSpanEnd = list.nodes.last.span.end.offset;
-    final nextNewLineIndex = yaml.indexOf('\n', lastValueSpanEnd - 1);
-    if (nextNewLineIndex == -1) {
-      formattedValue = getLineEnding(yaml) + formattedValue;
-    } else {
-      offset = nextNewLineIndex + 1;
-    }
+  // Lazily skip all comments and white-space at the end.
+  final offset = skipAndExtractCommentsInBlock(
+    yaml,
+    endOfNodeOffset: list.nodes.last.span.end.offset,
+    lineEnding: lineEnding,
+  ).endOffset;
+
+  var (indentSize, formattedValue) = _formatNewBlock(yamlEdit, list, item);
+
+  formattedValue = normalizeEncodedBlock(
+    yaml,
+    lineEnding: lineEnding,
+    nodeToReplaceEndOffset: offset,
+    update: item,
+    updateAsString: formattedValue,
+  );
+
+  formattedValue = '${' ' * indentSize}$formattedValue';
+
+  // Apply line ending incase it's missing
+  if (yaml[offset - 1] != '\n') {
+    formattedValue = '$lineEnding$formattedValue';
   }
 
   return SourceEdit(offset, 0, formattedValue);
@@ -146,7 +183,7 @@ SourceEdit _appendToBlockList(
     valueString = valueString.substring(newIndentation);
   }
 
-  return (listIndentation, '- $valueString$lineEnding');
+  return (listIndentation, '- $valueString');
 }
 
 /// Formats [item] into a new node for flow lists.
@@ -239,7 +276,7 @@ SourceEdit _insertInBlockList(
 /// ```
 (bool isNested, int offset) _isNestedInBlockList(
     int currentSequenceOffset, String yaml) {
-  final startIndex = currentSequenceOffset - 1;
+  final startOffset = currentSequenceOffset - 1;
 
   /// Indicates the element we are inserting before is at index `0` of the list
   /// at the root of the yaml
@@ -248,10 +285,10 @@ SourceEdit _insertInBlockList(
   ///
   /// - foo
   /// ^ Inserting before this
-  if (startIndex < 0) return (false, 0);
+  if (startOffset < 0) return (false, 0);
 
-  final newLineStart = yaml.lastIndexOf('\n', startIndex);
-  final seqStart = yaml.lastIndexOf('-', startIndex);
+  final newLineStart = yaml.lastIndexOf('\n', startOffset);
+  final seqStart = yaml.lastIndexOf('-', startOffset);
 
   /// Indicates that a `\n` is closer to the last `-`. Meaning this list is not
   /// nested.
@@ -308,70 +345,84 @@ SourceEdit _removeFromBlockList(
     YamlEditor yamlEdit, YamlList list, YamlNode nodeToRemove, int index) {
   RangeError.checkValueInInterval(index, 0, list.length - 1);
 
-  var end = getContentSensitiveEnd(nodeToRemove);
-
-  /// If we are removing the last element in a block list, convert it into a
-  /// flow empty list.
-  if (list.length == 1) {
-    final start = list.span.start.offset;
+  final yaml = yamlEdit.toString();
+  final yamlSize = yaml.length;
 
-    return SourceEdit(start, end - start, '[]');
+  final lineEnding = getLineEnding(yaml);
+  final YamlNode(:span) = nodeToRemove;
+
+  var startOffset = span.start.offset;
+  startOffset =
+      span.length == 0 ? startOffset : yaml.lastIndexOf('-', startOffset - 1);
+
+  var endOffset = getContentSensitiveEnd(nodeToRemove);
+
+  /// YamlMap may have `null` value for the last key and we need to ensure the
+  /// correct [endOffset] is provided to [skipAndExtractCommentsInBlock],
+  /// otherwise [skipAndExtractCommentsInBlock] may prematurely return an
+  /// incorrect offset because it immediately saw `:`
+  if (nodeToRemove is YamlMap &&
+      endOffset < yamlSize &&
+      nodeToRemove.nodes.entries.last.value.value == null) {
+    endOffset += 1;
   }
 
-  final yaml = yamlEdit.toString();
-  final span = nodeToRemove.span;
+  // We remove any content belonging to [nodeToRemove] greedily
+  endOffset = skipAndExtractCommentsInBlock(
+    yaml,
+    endOfNodeOffset: endOffset == startOffset ? endOffset + 1 : endOffset,
+    lineEnding: lineEnding,
+    greedy: true,
+  ).endOffset;
 
-  /// Adjust the end to clear the new line after the end too.
-  ///
-  /// We do this because we suspect that our users will want the inline
-  /// comments to disappear too.
-  final nextNewLine = yaml.indexOf('\n', end);
-  if (nextNewLine != -1) {
-    end = nextNewLine + 1;
-  }
+  final listSize = list.length;
+
+  final isSingleElement = listSize == 1;
+  final isLastElementInList = index == listSize - 1;
+  final isLastInYaml = endOffset == yamlSize;
+
+  final replacement = isSingleElement ? '[]' : '';
 
-  /// If the value is empty
-  if (span.length == 0) {
-    var start = span.start.offset;
-    return SourceEdit(start, end - start, '');
+  /// Adjust [startIndent] to include any indent this element may have had
+  /// to prevent it from interfering with the indent of the next [YamlNode]
+  /// which isn't in this list. We move it back if:
+  ///   1. The [nodeToRemove] is the last element in a [list] with more than
+  ///      one element.
+  ///   2. It also isn't the first element in the yaml.
+  ///
+  /// Doing this only for the last element ensures that any value's indent is
+  /// automatically given to the next element in the list such that,
+  ///
+  /// 1. If nested:
+  ///     -  - value
+  ///      ^ This space goes to the next element that ends up here
+  ///
+  /// 2. If not nested, then the next element gets the indent if any is present.
+  if (isLastElementInList && startOffset != 0 && !isSingleElement) {
+    final index = yaml.lastIndexOf('\n', startOffset);
+    startOffset = index == -1 ? startOffset : index + 1;
   }
 
-  /// -1 accounts for the fact that the content can start with a dash
-  var start = yaml.lastIndexOf('-', span.start.offset - 1);
-
-  /// Check if there is a `-` before the node
-  if (start > 0) {
-    final lastHyphen = yaml.lastIndexOf('-', start - 1);
-    final lastNewLine = yaml.lastIndexOf('\n', start - 1);
-    if (lastHyphen > lastNewLine) {
-      start = lastHyphen + 2;
-
-      /// If there is a `-` before the node, we need to check if we have
-      /// to update the indentation of the next node.
-      if (index < list.length - 1) {
-        /// Since [end] is currently set to the next new line after the current
-        /// node, check if we see a possible comment first, or a hyphen first.
-        /// Note that no actual content can appear here.
-        ///
-        /// We check this way because the start of a span in a block list is
-        /// the start of its value, and checking from the back leaves us
-        /// easily confused if there are comments that have dashes in them.
-        final nextHash = yaml.indexOf('#', end);
-        final nextHyphen = yaml.indexOf('-', end);
-        final nextNewLine = yaml.indexOf('\n', end);
-
-        /// If [end] is on the same line as the hyphen of the next node
-        if ((nextHash == -1 || nextHyphen < nextHash) &&
-            nextHyphen < nextNewLine) {
-          end = nextHyphen;
-        }
-      }
-    } else if (lastNewLine > lastHyphen) {
-      start = lastNewLine + 1;
-    }
+  /// We intentionally [skipAndExtractCommentsInBlock] greedily which also
+  /// consumes the next [YamlNode]'s indent.
+  ///
+  /// For elements at the last index, we need to reclaim the indent belonging
+  /// to the next node not in the list and optionally include a line break if
+  /// if it is the only element. See [reclaimIndentAndLinebreak] for more info.
+  if (isLastElementInList && !isLastInYaml) {
+    endOffset = reclaimIndentAndLinebreak(
+      yaml,
+      endOffset,
+      isSingle: isSingleElement,
+    );
+  } else if (isLastInYaml && yaml[endOffset - 1] == '\n' && isSingleElement) {
+    /// Remove any dangling line-break that may have been part of the yaml:
+    ///   -`\r\n` = 2
+    ///   - `\n` = 1
+    endOffset -= lineEnding == '\n' ? 1 : 2;
   }
 
-  return SourceEdit(start, end - start, '');
+  return SourceEdit(startOffset, endOffset - startOffset, replacement);
 }
 
 /// Returns a [SourceEdit] describing the change to be made on [yamlEdit] to