prettier 0.21.0 → 1.0.1

data/src/nodes/statements.js

@@ -1,4 +1,5 @@
 const {
+  breakParent,
   concat,
   dedent,
   group,
@@ -11,63 +12,104 @@ const {
   trim
 } = require("../prettier");
 
-module.exports = {
-  "@__end__": (path, _opts, _print) => {
-    const { body } = path.getValue();
-    return concat([trim, "__END__", literalline, body]);
-  },
-  bodystmt: (path, opts, print) => {
-    const [_statements, rescue, elseClause, ensure] = path.getValue().body;
-    const parts = [path.call(print, "body", 0)];
+function printBodyStmt(path, opts, print) {
+  const [stmts, rescue, elseClause, ensure] = path.getValue().body;
+  const parts = [];
 
-    if (rescue) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
-    }
+  if (
+    stmts.body.length > 1 ||
+    stmts.body[0].type != "void_stmt" ||
+    stmts.body[0].comments
+  ) {
+    parts.push(path.call(print, "body", 0));
+  }
 
-    if (elseClause) {
-      // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-      const stmts =
-        elseClause.type === "else"
-          ? path.call(print, "body", 2, "body", 0)
-          : path.call(print, "body", 2);
+  if (rescue) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
+  }
 
-      parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
-    }
+  if (elseClause) {
+    // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+    const stmts =
+      elseClause.type === "else"
+        ? path.call(print, "body", 2, "body", 0)
+        : path.call(print, "body", 2);
 
-    if (ensure) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
-    }
+    parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
+  }
 
-    return group(concat(parts));
-  },
-  embdoc: (path, _opts, _print) => concat([trim, path.getValue().body]),
-  paren: (path, opts, print) => {
-    if (!path.getValue().body[0]) {
-      return "()";
-    }
+  if (ensure) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
+  }
 
-    let content = path.call(print, "body", 0);
+  return group(concat(parts));
+}
 
-    if (
-      ["args", "args_add_star", "args_add_block"].includes(
-        path.getValue().body[0].type
-      )
-    ) {
-      content = join(concat([",", line]), content);
-    }
+const argNodeTypes = ["args", "args_add_star", "args_add_block"];
+
+function printParen(path, opts, print) {
+  const contentNode = path.getValue().body[0];
 
-    return group(
-      concat([
-        "(",
-        indent(concat([softline, content])),
-        concat([softline, ")"])
-      ])
-    );
+  if (!contentNode) {
+    return "()";
+  }
+
+  let contentDoc = path.call(print, "body", 0);
+
+  // If the content is params, we're going to let it handle its own parentheses
+  // so that it breaks nicely.
+  if (contentNode.type === "params") {
+    return contentDoc;
+  }
+
+  // If we have an arg type node as the contents, then it's going to return an
+  // array, so we need to explicitly join that content here.
+  if (argNodeTypes.includes(contentNode.type)) {
+    contentDoc = join(concat([",", line]), contentDoc);
+  }
+
+  return group(
+    concat([
+      "(",
+      indent(concat([softline, contentDoc])),
+      concat([softline, ")"])
+    ])
+  );
+}
+
+module.exports = {
+  "@__end__": (path, _opts, _print) => {
+    const { body } = path.getValue();
+    return concat([trim, "__END__", literalline, body]);
   },
+  bodystmt: printBodyStmt,
+  paren: printParen,
   program: (path, opts, print) =>
     concat([join(hardline, path.map(print, "body")), hardline]),
   stmts: (path, opts, print) => {
     const stmts = path.getValue().body;
+
+    // This is a special case where we have only comments inside a statement
+    // list. In this case we want to avoid doing any kind of line number
+    // tracking and just print out the comments.
+    if (
+      stmts.length === 1 &&
+      stmts[0].type === "void_stmt" &&
+      stmts[0].comments
+    ) {
+      const comments = path.map(
+        (commentPath) => {
+          commentPath.getValue().printed = true;
+          return opts.printer.printComment(commentPath);
+        },
+        "body",
+        0,
+        "comments"
+      );
+
+      return concat([breakParent, join(hardline, comments)]);
+    }
+
     const parts = [];
     let lineNo = null;
 

data/src/nodes/strings.js

@@ -8,31 +8,31 @@ const {
   join
 } = require("../prettier");
 
-const { concatBody, empty, makeList, prefix, surround } = require("../utils");
-
 // If there is some part of this string that matches an escape sequence or that
 // contains the interpolation pattern ("#{"), then we are locked into whichever
 // quote the user chose. (If they chose single quotes, then double quoting
 // would activate the escape sequence, and if they chose double quotes, then
 // single quotes would deactivate it.)
-const isQuoteLocked = (string) =>
-  string.body.some(
+function isQuoteLocked(node) {
+  return node.body.some(
     (part) =>
       part.type === "@tstring_content" &&
       (part.body.includes("#{") || part.body.includes("\\"))
   );
+}
 
 // A string is considered to be able to use single quotes if it contains only
 // plain string content and that content does not contain a single quote.
-const isSingleQuotable = (string) =>
-  string.body.every(
+function isSingleQuotable(node) {
+  return node.body.every(
     (part) => part.type === "@tstring_content" && !part.body.includes("'")
   );
+}
 
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
-const normalizeQuotes = (content, enclosingQuote, originalQuote) => {
-  const replaceOther = ["'", '"'].includes(originalQuote);
+function normalizeQuotes(content, enclosingQuote, originalQuote) {
+  const replaceOther = originalQuote === '"';
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
 
   // Escape and unescape single and double quotes as needed to be able to
@@ -52,7 +52,7 @@ const normalizeQuotes = (content, enclosingQuote, originalQuote) => {
 
     return `\\${escaped}`;
   });
-};
+}
 
 const quotePairs = {
   "(": ")",
@@ -61,51 +61,100 @@ const quotePairs = {
   "<": ">"
 };
 
-const getClosingQuote = (quote) => {
+function getClosingQuote(quote) {
   if (!quote.startsWith("%")) {
     return quote;
   }
 
-  const boundary = /%q?(.)/.exec(quote)[1];
+  const boundary = /%[Qq]?(.)/.exec(quote)[1];
   if (boundary in quotePairs) {
     return quotePairs[boundary];
   }
 
   return boundary;
-};
+}
 
-module.exports = {
-  "@CHAR": (path, { preferSingleQuotes }, _print) => {
-    const { body } = path.getValue();
+// Prints a @CHAR node. @CHAR nodes are special character strings that usually
+// are strings of length 1. If they're any longer than we'll try to apply the
+// correct quotes.
+function printChar(path, { rubySingleQuote }, _print) {
+  const { body } = path.getValue();
 
-    if (body.length !== 2) {
-      return body;
+  if (body.length !== 2) {
+    return body;
+  }
+
+  const quote = rubySingleQuote ? "'" : '"';
+  return concat([quote, body.slice(1), quote]);
+}
+
+// Prints a dynamic symbol. Assumes there's a quote property attached to the
+// node that will tell us which quote to use when printing. We're just going to
+// use whatever quote was provided.
+function printDynaSymbol(path, opts, print) {
+  const { quote } = path.getValue();
+
+  return concat([":", quote].concat(path.map(print, "body")).concat(quote));
+}
+
+// Prints out an interpolated variable in the string by converting it into an
+// embedded expression.
+function printStringDVar(path, opts, print) {
+  return concat(["#{", path.call(print, "body", 0), "}"]);
+}
+
+// Prints out a literal string. This function does its best to respect the
+// wishes of the user with regards to single versus double quotes, but if the
+// string contains any escape expressions then it will just keep the original
+// quotes.
+function printStringLiteral(path, { rubySingleQuote }, print) {
+  const node = path.getValue();
+
+  // If the string is empty, it will not have any parts, so just print out the
+  // quotes corresponding to the config
+  if (node.body.length === 0) {
+    return rubySingleQuote ? "''" : '""';
+  }
+
+  // Determine the quote that should enclose the new string
+  let quote;
+  if (isQuoteLocked(node)) {
+    quote = node.quote;
+  } else {
+    quote = rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
+  }
+
+  const parts = node.body.map((part, index) => {
+    if (part.type !== "@tstring_content") {
+      // In this case, the part of the string is an embedded expression
+      return path.call(print, "body", index);
     }
 
-    const quote = preferSingleQuotes ? "'" : '"';
-    return body.length === 2 ? concat([quote, body.slice(1), quote]) : body;
-  },
-  dyna_symbol: (path, opts, print) => {
-    const { quote } = path.getValue();
+    // In this case, the part of the string is just regular string content
+    return join(
+      literalline,
+      normalizeQuotes(part.body, quote, node.quote).split("\n")
+    );
+  });
 
-    return concat([":", quote, concat(path.call(print, "body", 0)), quote]);
-  },
-  heredoc: (path, opts, print) => {
-    const { beging, body, ending } = path.getValue();
+  return concat([quote].concat(parts).concat(getClosingQuote(quote)));
+}
 
-    const parts = body.map((part, index) => {
-      if (part.type !== "@tstring_content") {
-        // In this case, the part of the string is an embedded expression
-        return path.call(print, "body", index);
-      }
+// Prints out a symbol literal. Its child will always be the ident that
+// represents the string content of the symbol.
+function printSymbolLiteral(path, opts, print) {
+  return concat([":", path.call(print, "body", 0)]);
+}
 
-      // In this case, the part of the string is just regular string content
-      return join(literalline, part.body.split("\n"));
-    });
+// Prints out an xstring literal. Its child is an array of string parts,
+// including plain string content and interpolated content.
+function printXStringLiteral(path, opts, print) {
+  return concat(["`"].concat(path.map(print, "body")).concat("`"));
+}
 
-    return concat([beging, literalline, concat(parts), ending]);
-  },
-  string: makeList,
+module.exports = {
+  "@CHAR": printChar,
+  dyna_symbol: printDynaSymbol,
   string_concat: (path, opts, print) =>
     group(
       concat([
@@ -114,14 +163,15 @@ module.exports = {
         indent(concat([hardline, path.call(print, "body", 1)]))
       ])
     ),
-  string_dvar: surround("#{", "}"),
+  string_dvar: printStringDVar,
   string_embexpr: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 
-    // If the interpolated expression is inside of an xstring literal (a string
-    // that gets sent to the command line) then we don't want to automatically
-    // indent, as this can lead to some very odd looking expressions
-    if (path.getParentNode().type === "xstring") {
+    // If the interpolated expression is inside of a heredoc or an xstring
+    // literal (a string that gets sent to the command line) then we don't want
+    // to automatically indent, as this can lead to some very odd looking
+    // expressions
+    if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
       return concat(["#{", parts, "}"]);
     }
 
@@ -129,47 +179,7 @@ module.exports = {
       concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
     );
   },
-  string_literal: (path, { preferSingleQuotes }, print) => {
-    const stringLiteral = path.getValue();
-    const string = stringLiteral.body[0];
-
-    // If the string is empty, it will not have any parts, so just print out the
-    // quotes corresponding to the config
-    if (string.body.length === 0) {
-      return preferSingleQuotes ? "''" : '""';
-    }
-
-    // Determine the quote that should enclose the new string
-    let quote;
-    if (isQuoteLocked(string)) {
-      ({ quote } = stringLiteral);
-    } else {
-      quote = preferSingleQuotes && isSingleQuotable(string) ? "'" : '"';
-    }
-
-    const parts = string.body.map((part, index) => {
-      if (part.type !== "@tstring_content") {
-        // In this case, the part of the string is an embedded expression
-        return path.call(print, "body", 0, "body", index);
-      }
-
-      // In this case, the part of the string is just regular string content
-      return join(
-        literalline,
-        normalizeQuotes(part.body, quote, stringLiteral.quote).split("\n")
-      );
-    });
-
-    return concat([quote].concat(parts).concat(getClosingQuote(quote)));
-  },
-  symbol: prefix(":"),
-  symbol_literal: concatBody,
-  word_add: concatBody,
-  word_new: empty,
-  xstring: makeList,
-  xstring_literal: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    return concat(["`"].concat(parts).concat("`"));
-  }
+  string_literal: printStringLiteral,
+  symbol_literal: printSymbolLiteral,
+  xstring_literal: printXStringLiteral
 };

data/src/nodes/super.js

@@ -0,0 +1,35 @@
+const { align, concat, group, join, line } = require("../prettier");
+const { literal } = require("../utils");
+
+function printSuper(path, opts, print) {
+  const args = path.getValue().body[0];
+
+  if (args.type === "arg_paren") {
+    // In case there are explicitly no arguments but they are using parens,
+    // we assume they are attempting to override the initializer and pass no
+    // arguments up.
+    if (args.body[0] === null) {
+      return "super()";
+    }
+
+    return concat(["super", path.call(print, "body", 0)]);
+  }
+
+  const keyword = "super ";
+  const argsDocs = path.call(print, "body", 0);
+
+  return group(
+    concat([
+      keyword,
+      align(keyword.length, group(join(concat([",", line]), argsDocs)))
+    ])
+  );
+}
+
+// Version of super without any parens or args.
+const printZSuper = literal("super");
+
+module.exports = {
+  super: printSuper,
+  zsuper: printZSuper
+};

data/src/nodes/undef.js

@@ -0,0 +1,42 @@
+const {
+  addTrailingComment,
+  align,
+  concat,
+  group,
+  join,
+  line
+} = require("../prettier");
+
+function printUndefSymbol(path, opts, print) {
+  const node = path.getValue();
+
+  // Since we're going to descend into the symbol literal to grab out the ident
+  // node, then we need to make sure we copy over any comments as well,
+  // otherwise we could accidentally skip printing them.
+  if (node.comments) {
+    node.comments.forEach((comment) => {
+      addTrailingComment(node.body[0], comment);
+    });
+  }
+
+  return path.call(print, "body", 0);
+}
+
+function printUndef(path, opts, print) {
+  const keyword = "undef ";
+  const argNodes = path.map(
+    (symbolPath) => printUndefSymbol(symbolPath, opts, print),
+    "body"
+  );
+
+  return group(
+    concat([
+      keyword,
+      align(keyword.length, join(concat([",", line]), argNodes))
+    ])
+  );
+}
+
+module.exports = {
+  undef: printUndef
+};