printBlockString: replace 'preferMultipleLines' with 'options.minimize'

Author: IvanGoncharov

src/language/__tests__/blockString-fuzz.ts

@@ -21,9 +21,9 @@ function lexValue(str: string): string {
 
 function testPrintableBlockString(
   testValue: string,
-  preferMultipleLines?: boolean,
+  options?: { minimize: boolean },
 ): void {
-  const blockString = printBlockString(testValue, preferMultipleLines);
+  const blockString = printBlockString(testValue, options);
   const printedValue = lexValue(blockString);
   invariant(
     testValue === printedValue,
@@ -54,8 +54,7 @@ describe('printBlockString', () => {
       invariant(typeof testValue === 'string');
 
       testPrintableBlockString(testValue);
-      testPrintableBlockString(testValue, true);
-      testPrintableBlockString(testValue, false);
+      testPrintableBlockString(testValue, { minimize: true });
     }
   }).timeout(20000);
 });

src/language/__tests__/blockString-test.ts

@@ -136,66 +136,67 @@ describe('dedentBlockStringLines', () => {
 });
 
 describe('printBlockString', () => {
-  function expectBlockString(str: string, preferMultipleLines?: boolean) {
-    return expect(printBlockString(str, preferMultipleLines));
+  function expectBlockString(str: string) {
+    return {
+      toEqual(expected: string | { readable: string; minimize: string }) {
+        const { readable, minimize } =
+          typeof expected === 'string'
+            ? { readable: expected, minimize: expected }
+            : expected;
+
+        expect(printBlockString(str)).to.equal(readable);
+        expect(printBlockString(str, { minimize: true })).to.equal(minimize);
+      },
+    };
   }
 
   it('do not escape characters', () => {
     const str = '" \\ / \b \f \n \r \t';
-    expectBlockString(str).to.equal('"""\n' + str + '\n"""');
+    expectBlockString(str).toEqual({
+      readable: '"""\n' + str + '\n"""',
+      minimize: '"""\n' + str + '"""',
+    });
   });
 
   it('by default print block strings as single line', () => {
     const str = 'one liner';
-    expectBlockString(str).to.equal('"""one liner"""');
-    expectBlockString(str, true).to.equal('"""\none liner\n"""');
-    expectBlockString(str, false).to.equal('"""one liner"""');
+    expectBlockString(str).toEqual('"""one liner"""');
   });
 
   it('by default print block strings ending with triple quotation as multi-line', () => {
     const str = 'triple quotation """';
-    expectBlockString(str).to.equal('"""\ntriple quotation \\"""\n"""');
-    expectBlockString(str, true).to.equal('"""\ntriple quotation \\"""\n"""');
-    expectBlockString(str, false).to.equal('"""triple quotation \\""""""');
+    expectBlockString(str).toEqual({
+      readable: '"""\ntriple quotation \\"""\n"""',
+      minimize: '"""triple quotation \\""""""',
+    });
   });
 
   it('correctly prints single-line with leading space', () => {
     const str = '    space-led string';
-    expectBlockString(str).to.equal('"""    space-led string"""');
-    expectBlockString(str, true).to.equal('"""    space-led string\n"""');
-    expectBlockString(str, false).to.equal('"""    space-led string"""');
+    expectBlockString(str).toEqual('"""    space-led string"""');
   });
 
   it('correctly prints single-line with leading space and trailing quotation', () => {
     const str = '    space-led value "quoted string"';
-
-    expectBlockString(str).to.equal(
-      '"""    space-led value "quoted string"\n"""',
-    );
-
-    expectBlockString(str, true).to.equal(
-      '"""    space-led value "quoted string"\n"""',
-    );
-
-    expectBlockString(str, false).to.equal(
+    expectBlockString(str).toEqual(
       '"""    space-led value "quoted string"\n"""',
     );
   });
 
   it('correctly prints single-line with trailing backslash', () => {
     const str = 'backslash \\';
-
-    expectBlockString(str).to.equal('"""\nbackslash \\\n"""');
-    expectBlockString(str, true).to.equal('"""\nbackslash \\\n"""');
-    expectBlockString(str, false).to.equal('"""backslash \\\n"""');
+    expectBlockString(str).toEqual({
+      readable: '"""\nbackslash \\\n"""',
+      minimize: '"""backslash \\\n"""',
+    });
   });
 
   it('correctly prints multi-line with internal indent', () => {
     const str = 'no indent\n with indent';
-
-    expectBlockString(str).to.equal('"""\nno indent\n with indent\n"""');
-    expectBlockString(str, true).to.equal('"""\nno indent\n with indent\n"""');
-    expectBlockString(str, false).to.equal('"""\nno indent\n with indent"""');
+    expectBlockString(str).toEqual({
+      readable: '"""\nno indent\n with indent\n"""',
+      minimize: '"""\nno indent\n with indent"""',
+    });
   });
 
   it('correctly prints string with a first line indentation', () => {
@@ -206,15 +207,21 @@ describe('printBlockString', () => {
       '     string',
     );
 
-    expectBlockString(str).to.equal(
-      joinLines(
+    expectBlockString(str).toEqual({
+      readable: joinLines(
         '"""',
         '    first  ',
         '  line     ',
         'indentation',
         '     string',
         '"""',
       ),
-    );
+      minimize: joinLines(
+        '"""    first  ',
+        '  line     ',
+        'indentation',
+        '     string"""',
+      ),
+    });
   });
 });

src/language/blockString.ts

@@ -53,27 +53,24 @@ function leadingWhitespace(str: string): number {
  * trailing blank line. However, if a block string starts with whitespace and is
  * a single-line, adding a leading blank line would strip that whitespace.
  *
- * `preferMultipleLines` has following semantics:
- *    * `true` - add leading and trailing new lines if possible
- *    * `false` - don't add leading and trailing new lines if possible
- *    * `undefined` - add leading and trailing new lines only if it improves readability
- *
  * @internal
  */
 export function printBlockString(
   value: string,
-  preferMultipleLines?: boolean,
+  options?: { minimize?: boolean },
 ): string {
   const escapedValue = value.replace(/"""/g, '\\"""');
 
   // Expand a block string's raw value into independent lines.
   const lines = escapedValue.split(/\r\n|[\n\r]/g);
   const isSingleLine = lines.length === 1;
 
-  // If common identation is found we can fix some of those cases by adding leading new line
+  // If common indentation is found we can fix some of those cases by adding leading new line
   const forceLeadingNewLine =
     lines.length > 1 &&
-    lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
+    lines
+      .slice(1)
+      .every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
 
   // Trailing triple quotes just looks confusing but doesn't force trailing new line
   const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""');
@@ -84,9 +81,10 @@ export function printBlockString(
   const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
 
   const printAsMultipleLines =
-    preferMultipleLines ??
+    !options?.minimize &&
     // add leading and trailing new lines only if it improves readability
     (!isSingleLine ||
+      value.length > 70 ||
       forceTrailingNewline ||
       forceLeadingNewLine ||
       hasTrailingTripleQuotes);

src/utilities/printSchema.ts

@@ -4,7 +4,6 @@ import type { Maybe } from '../jsutils/Maybe';
 
 import { Kind } from '../language/kinds';
 import { print } from '../language/printer';
-import { printBlockString } from '../language/blockString';
 
 import type { GraphQLSchema } from '../type/schema';
 import type { GraphQLDirective } from '../type/directives';
@@ -314,8 +313,12 @@ function printDescription(
     return '';
   }
 
-  const preferMultipleLines = description.length > 70;
-  const blockString = printBlockString(description, preferMultipleLines);
+  const blockString = print({
+    kind: Kind.STRING,
+    value: description,
+    block: true,
+  });
+
   const prefix =
     indentation && !firstInBlock ? '\n' + indentation : indentation;
 

src/utilities/stripIgnoredCharacters.ts

@@ -89,7 +89,7 @@ export function stripIgnoredCharacters(source: string | Source): string {
 
     const tokenBody = body.slice(currentToken.start, currentToken.end);
     if (tokenKind === TokenKind.BLOCK_STRING) {
-      strippedBody += printBlockString(currentToken.value, false);
+      strippedBody += printBlockString(currentToken.value, { minimize: true });
     } else {
       strippedBody += tokenBody;
     }