[WIP] Refactoring to change strings into block scalars

TODO:
- [ ] Translations (I think the French one is probably wrong)
- [ ] Handle leading spaces correctly (leading spaces are ignored, so we
  need another way to preserve them)
- [ ] Tests, especially for edge cases

Fixes #1119

Signed-off-by: David Thompson <[email protected]>

Author: datho7561

.vscode/tasks.json

@@ -6,7 +6,7 @@
     {
       "label": "watch typescript",
       "type": "shell",
-      "command": "yarn run watch",
+      "command": "npm run watch",
       "presentation": {
         "reveal": "never"
       },

l10n/bundle.l10n.fr.json

@@ -52,5 +52,7 @@
   "flowStyleMapForbidden": "Le mappage de style de flux est interdit",
   "flowStyleSeqForbidden": "La séquence de style Flow est interdite",
   "unUsedAnchor": "Ancre inutilisée '{0}'",
-  "unUsedAlias": "Alias ​​non résolu '{0}'"
+  "unUsedAlias": "Alias non résolu '{0}'",
+  "convertToFoldedBlockString": "Convertir la chaîne en style de bloc plie",
+  "convertToLiteralBlockString": "Convertir la chaîne en style de bloc literale"
 }

l10n/bundle.l10n.json

@@ -52,5 +52,7 @@
   "flowStyleMapForbidden": "Flow style mapping is forbidden",
   "flowStyleSeqForbidden": "Flow style sequence is forbidden",
   "unUsedAnchor": "Unused anchor \"{0}\"",
-  "unUsedAlias": "Unresolved alias \"{0}\""  
+  "unUsedAlias": "Unresolved alias \"{0}\"",
+  "convertToFoldedBlockString": "Convert string to folded block string",
+  "convertToLiteralBlockString": "Convert string to literal block string"
 }

src/languageservice/services/yamlCodeActions.ts

@@ -22,14 +22,15 @@ import { LanguageSettings } from '../yamlLanguageService';
 import { YAML_SOURCE } from '../parser/jsonParser07';
 import { getFirstNonWhitespaceCharacterAfterOffset } from '../utils/strings';
 import { matchOffsetToDocument } from '../utils/arrUtils';
-import { CST, isMap, isSeq, YAMLMap } from 'yaml';
+import { CST, isMap, isScalar, isSeq, Scalar, visit, YAMLMap } from 'yaml';
 import { yamlDocumentsCache } from '../parser/yaml-documents';
 import { FlowStyleRewriter } from '../utils/flow-style-rewriter';
 import { ASTNode } from '../jsonASTTypes';
 import * as _ from 'lodash';
 import { SourceToken } from 'yaml/dist/parse/cst';
 import { ErrorCode } from 'vscode-json-languageservice';
 import * as l10n from '@vscode/l10n';
+import { BlockStringRewriter } from '../utils/block-string-rewriter';
 
 interface YamlDiagnosticData {
   schemaUri: string[];
@@ -57,6 +58,7 @@ export class YamlCodeActions {
     result.push(...this.getTabToSpaceConverting(params.context.diagnostics, document));
     result.push(...this.getUnusedAnchorsDelete(params.context.diagnostics, document));
     result.push(...this.getConvertToBlockStyleActions(params.context.diagnostics, document));
+    result.push(...this.getConvertStringToBlockStyleActions(params.context.diagnostics, document));
     result.push(...this.getKeyOrderActions(params.context.diagnostics, document));
     result.push(...this.getQuickFixForPropertyOrValueMismatch(params.context.diagnostics, document));
 
@@ -243,6 +245,50 @@ export class YamlCodeActions {
     return results;
   }
 
+  private getConvertStringToBlockStyleActions(diagnostics: Diagnostic[], document: TextDocument): CodeAction[] {
+    const yamlDocument = yamlDocumentsCache.getYamlDocument(document);
+
+    const results: CodeAction[] = [];
+    for (const singleYamlDocument of yamlDocument.documents) {
+      const matchingNodes: Scalar<string>[] = [];
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      visit(singleYamlDocument.internalDocument, (key, node, path) => {
+        if (isScalar(node)) {
+          if (node.type === 'PLAIN' || node.type === 'QUOTE_DOUBLE' || node.type === 'QUOTE_SINGLE') {
+            if (typeof node.value === 'string' && (node.value.indexOf('\n') >= 0 || node.value.length > 120)) {
+              matchingNodes.push(<Scalar<string>>node);
+            }
+          }
+        }
+      });
+      for (const node of matchingNodes) {
+        const range = Range.create(document.positionAt(node.range[0]), document.positionAt(node.range[2]));
+        const rewriter = new BlockStringRewriter(this.indentation);
+        const foldedBlockScalar = rewriter.writeFoldedBlockScalar(node);
+        if (foldedBlockScalar !== null) {
+          results.push(
+            CodeAction.create(
+              l10n.t('convertToFoldedBlockString'),
+              createWorkspaceEdit(document.uri, [TextEdit.replace(range, foldedBlockScalar)]),
+              CodeActionKind.Refactor
+            )
+          );
+        }
+        const literalBlockScalar = rewriter.writeLiteralBlockScalar(node);
+        if (literalBlockScalar !== null) {
+          results.push(
+            CodeAction.create(
+              l10n.t('convertToLiteralBlockString'),
+              createWorkspaceEdit(document.uri, [TextEdit.replace(range, literalBlockScalar)]),
+              CodeActionKind.Refactor
+            )
+          );
+        }
+      }
+    }
+    return results;
+  }
+
   private getKeyOrderActions(diagnostics: Diagnostic[], document: TextDocument): CodeAction[] {
     const results: CodeAction[] = [];
     for (const diagnostic of diagnostics) {

src/languageservice/utils/block-string-rewriter.ts

@@ -0,0 +1,138 @@
+import { CST, Scalar } from 'yaml';
+
+export class BlockStringRewriter {
+  constructor(private readonly indentation: string) {}
+
+  public writeFoldedBlockScalar(node: Scalar<string>): string | null {
+    if (node.type !== 'PLAIN' && node.type !== 'QUOTE_DOUBLE' && node.type !== 'QUOTE_SINGLE') {
+      return null;
+    }
+
+    const stringContent = node.value;
+
+    const lines: string[] = [];
+    let remainder = stringContent;
+    while (remainder.length > 120) {
+      const location = remainder.indexOf('\n') >= 0 ? Math.min(remainder.indexOf('\n'), 120) : 120;
+      if (remainder.charAt(0) === '\n') {
+        remainder = remainder.substring(1);
+      } else {
+        const head = remainder.substring(0, location);
+        lines.push(head);
+        remainder = remainder.substring(location);
+      }
+    }
+    lines.push(remainder);
+
+    const newProps: CST.Token[] = lines.flatMap((line) => {
+      if (line === '\n') {
+        // newlines can be represented as two newlines in folded blocks
+        return [
+          {
+            type: 'newline',
+            indent: 0,
+            offset: node.srcToken.offset,
+            source: '\n',
+          },
+          {
+            type: 'newline',
+            indent: 0,
+            offset: node.srcToken.offset,
+            source: '\n',
+          },
+        ];
+      }
+      return [
+        {
+          type: 'newline',
+          indent: 0,
+          offset: node.srcToken.offset,
+          source: '\n',
+        },
+        {
+          type: 'space',
+          indent: 0,
+          offset: node.srcToken.offset,
+          source: this.indentation,
+        },
+        {
+          type: 'scalar',
+          indent: 0,
+          offset: node.srcToken.offset,
+          source: line,
+        },
+      ];
+    });
+
+    newProps.unshift({
+      type: 'block-scalar-header',
+      source: '>',
+      offset: node.srcToken.offset,
+      indent: 0,
+    });
+
+    const blockString: CST.BlockScalar = {
+      type: 'block-scalar',
+      offset: node.srcToken.offset,
+      indent: 0,
+      source: '',
+      props: newProps,
+    };
+
+    return CST.stringify(blockString as CST.Token);
+  }
+
+  public writeLiteralBlockScalar(node: Scalar<string>): string | null {
+    if (node.type !== 'PLAIN' && node.type !== 'QUOTE_DOUBLE' && node.type !== 'QUOTE_SINGLE') {
+      return null;
+    }
+
+    const stringContent = node.value;
+    // I don't think it's worth it
+    if (stringContent.indexOf('\n') < 0) {
+      return null;
+    }
+
+    const lines: string[] = stringContent.split('\n');
+
+    const newProps: CST.Token[] = lines.flatMap((line) => {
+      return [
+        {
+          type: 'newline',
+          indent: 0,
+          offset: node.srcToken.offset,
+          source: '\n',
+        },
+        {
+          type: 'space',
+          indent: 0,
+          offset: node.srcToken.offset,
+          source: this.indentation,
+        },
+        {
+          type: 'scalar',
+          indent: 0,
+          offset: node.srcToken.offset,
+          source: line,
+        },
+      ];
+    });
+
+    newProps.unshift({
+      type: 'block-scalar-header',
+      source: '|',
+      offset: node.srcToken.offset,
+      indent: 0,
+    });
+
+    const blockString: CST.BlockScalar = {
+      type: 'block-scalar',
+      offset: node.srcToken.offset,
+      indent: 0,
+      source: '',
+      props: newProps,
+    };
+
+    return CST.stringify(blockString as CST.Token);
+  }
+}