[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 === 'QUOTE_DOUBLE' || node.type === 'QUOTE_SINGLE') {
+            if (typeof node.value === 'string' && (node.value.indexOf('\n') >= 0 || node.value.length > 120) /* TODO: */) {
+              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, 120 /* TODO: */);
+        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,157 @@
+import { CST, Scalar } from 'yaml';
+
+export class BlockStringRewriter {
+  constructor(
+    private readonly indentation: string,
+    private readonly maxLineLength: number
+  ) {}
+
+  public writeFoldedBlockScalar(node: Scalar<string>): string | null {
+    if (node.type !== 'QUOTE_DOUBLE' && node.type !== 'QUOTE_SINGLE') {
+      return null;
+    }
+
+    const stringContent = node.value;
+
+    const lines: string[] = [];
+    const splitLines = stringContent.split('\n');
+    for (const line of splitLines) {
+      let remainder = line;
+      slicing: while (remainder.length > this.maxLineLength) {
+        let location = this.maxLineLength;
+        // for folded strings, space characters are placed in place of each line break
+        // so we need to split the line on a space and remove the space
+        while (!/ /.test(remainder.charAt(location))) {
+          location++;
+          if (location >= remainder.length) {
+            break slicing;
+          }
+        }
+        // however any leading space characters will be take literally and also a newline gets inserted
+        // so instead we need them to be trailing
+        // which could be problematic as "trim trailing whitespace" is a common setting to have enabled but oh well
+        while (/ /.test(remainder.charAt(location))) {
+          location++;
+          if (location >= remainder.length) {
+            break slicing;
+          }
+        }
+        const head = remainder.substring(
+          0,
+          location - 1 /* -1 to remove one space character, which is automatically added between lines */
+        );
+        lines.push(head);
+        remainder = remainder.substring(location);
+      }
+      lines.push(remainder);
+      lines.push('\n');
+    }
+    // no trailng newline
+    lines.pop();
+
+    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',
+          },
+        ];
+      }
+      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 !== '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);
+  }
+}

test/yamlCodeActions.test.ts

@@ -12,6 +12,7 @@ import {
   CodeActionContext,
   Command,
   DiagnosticSeverity,
+  Position,
   Range,
   TextDocumentIdentifier,
   TextEdit,
@@ -457,4 +458,64 @@ animals: [dog , cat , mouse]  `;
       expect(result[0].edit.changes[TEST_URI]).deep.equal([TextEdit.replace(Range.create(0, 5, 0, 11), '5')]);
     });
   });
+
+  describe('Change string to block string', function () {
+    it('should split up double quoted text with newlines', function () {
+      const doc = setupTextDocument('foo: "line 1\\nline 2\\nline 3"');
+      const params: CodeActionParams = {
+        context: CodeActionContext.create([]),
+        range: undefined,
+        textDocument: TextDocumentIdentifier.create(TEST_URI),
+      };
+      const actions = new YamlCodeActions(clientCapabilities);
+      const result = actions.getCodeAction(doc, params);
+      expect(result).to.have.length(2);
+      expect(result[0].title).to.equal('Convert string to folded block string');
+      const edit0: WorkspaceEdit = {
+        changes: {},
+      };
+      edit0.changes[TEST_URI] = [
+        TextEdit.replace(Range.create(Position.create(0, 5), Position.create(0, 29)), '>\n  line 1\n\n  line 2\n\n  line 3'),
+      ];
+      expect(result[0].edit).to.deep.equal(edit0);
+
+      expect(result[1].title).to.equal('Convert string to literal block string');
+      const edit1: WorkspaceEdit = {
+        changes: {},
+      };
+      edit1.changes[TEST_URI] = [
+        TextEdit.replace(Range.create(Position.create(0, 5), Position.create(0, 29)), '|\n  line 1\n  line 2\n  line 3'),
+      ];
+      expect(result[1].edit).to.deep.equal(edit1);
+    });
+    it('should split up long lines of double quoted text', function () {
+      let docContent = 'foo: "';
+      for (let i = 0; i < 120 / 4 + 1; i++) {
+        docContent += 'cat ';
+      }
+      docContent += 'cat"';
+      const doc = setupTextDocument(docContent);
+      const params: CodeActionParams = {
+        context: CodeActionContext.create([]),
+        range: undefined,
+        textDocument: TextDocumentIdentifier.create(TEST_URI),
+      };
+      const actions = new YamlCodeActions(clientCapabilities);
+      const result = actions.getCodeAction(doc, params);
+      expect(result).to.have.length(1);
+      expect(result[0].title).to.equal('Convert string to folded block string');
+      const edit0: WorkspaceEdit = {
+        changes: {},
+      };
+      let resultText = '>\n ';
+      for (let i = 0; i < 120 / 4; i++) {
+        resultText += ' cat';
+      }
+      resultText += ' cat\n  cat';
+      edit0.changes[TEST_URI] = [
+        TextEdit.replace(Range.create(Position.create(0, 5), Position.create(0, 5 + 120 + 8 + 1)), resultText),
+      ];
+      expect(result[0].edit).to.deep.equal(edit0);
+    });
+  });
 });