prettier 0.16.0 → 0.19.0

data/src/nodes/case.js

@@ -42,7 +42,7 @@ module.exports = {
 
     // It's possible in a when to just have empty void statements, in which case
     // we would skip adding the body.
-    if (!stmts.parts.every(part => !part)) {
+    if (!stmts.parts.every((part) => !part)) {
       parts.push(indent(concat([hardline, stmts])));
     }
 

data/src/nodes/commands.js

@@ -1,11 +1,27 @@
 const { align, concat, group, ifBreak, join, line } = require("../prettier");
 const { docLength, makeArgs, makeCall } = require("../utils");
 
-const hasDef = node =>
+const hasDef = (node) =>
   node.body[1].type === "args_add_block" &&
   node.body[1].body[0].type === "args" &&
   node.body[1].body[0].body[0] &&
-  node.body[1].body[0].body[0].type === "def";
+  ["def", "defs"].includes(node.body[1].body[0].body[0].type);
+
+// Very special handling case for rspec matchers. In general with rspec matchers
+// you expect to see something like:
+//
+//     expect(foo).to receive(:bar).with(
+//       'one',
+//       'two',
+//       'three',
+//       'four',
+//       'five'
+//     )
+//
+// In this case the arguments are aligned to the left side as opposed to being
+// aligned with the `receive` call.
+const skipArgsAlign = (path) =>
+  ["to", "not_to"].includes(path.getValue().body[2].body);
 
 module.exports = {
   command: (path, opts, print) => {
@@ -53,10 +69,9 @@ module.exports = {
     }
 
     const joinedArgs = join(concat([",", line]), args);
-    const breakArgs =
-      path.getValue().body[2].body === "to"
-        ? joinedArgs
-        : align(docLength(concat(parts)), joinedArgs);
+    const breakArgs = skipArgsAlign(path)
+      ? joinedArgs
+      : align(docLength(concat(parts)), joinedArgs);
 
     const commandDoc = group(
       ifBreak(concat(parts.concat(breakArgs)), concat(parts.concat(joinedArgs)))

data/src/nodes/conditionals.js

@@ -23,7 +23,7 @@ const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
 // For the unary `not` operator, we need to explicitly add parentheses to it in
 // order for it to be valid from within a ternary. Otherwise if the clause of
 // the ternary isn't a unary `not`, we can just pass it along.
-const printTernaryClause = clause => {
+const printTernaryClause = (clause) => {
   if (clause.type === "concat") {
     const [part] = clause.parts;
 
@@ -75,23 +75,21 @@ const printTernary = (path, _opts, print) => {
   );
 };
 
-const makeSingleBlockForm = (keyword, path, print) =>
-  concat([
+// Prints an `if_mod` or `unless_mod` node. Because it was previously in the
+// modifier form, we're guaranteed to not have an additional node, so we can
+// just work with the predicate and the body.
+const printSingle = (keyword) => (path, { inlineConditionals }, print) => {
+  const multiline = concat([
     `${keyword} `,
     align(keyword.length + 1, path.call(print, "body", 0)),
     indent(concat([softline, path.call(print, "body", 1)])),
     concat([softline, "end"])
   ]);
 
-// Prints an `if_mod` or `unless_mod` node. Because it was previously in the
-// modifier form, we're guaranteed to not have an additional node, so we can
-// just work with the predicate and the body.
-const printSingle = keyword => (path, { inlineConditionals }, print) => {
-  const multiline = makeSingleBlockForm(keyword, path, print);
-
   const [_predicate, stmts] = path.getValue().body;
   const hasComments =
-    stmts.type === "stmts" && stmts.body.some(stmt => stmt.type === "@comment");
+    stmts.type === "stmts" &&
+    stmts.body.some((stmt) => stmt.type === "@comment");
 
   if (!inlineConditionals || hasComments) {
     return multiline;
@@ -155,7 +153,7 @@ const noTernary = [
 // Certain expressions cannot be reduced to a ternary without adding parens
 // around them. In this case we say they cannot be ternaried and default instead
 // to breaking them into multiple lines.
-const canTernaryStmts = stmts => {
+const canTernaryStmts = (stmts) => {
   if (stmts.body.length !== 1) {
     return false;
   }
@@ -178,10 +176,11 @@ const canTernaryStmts = stmts => {
 // is of the "else" type. Both the body of the main node and the body of the
 // additional node must have only one statement, and that statement list must
 // pass the `canTernaryStmts` check.
-const canTernary = path => {
-  const [_pred, stmts, addition] = path.getValue().body;
+const canTernary = (path) => {
+  const [predicate, stmts, addition] = path.getValue().body;
 
   return (
+    !["assign", "opassign"].includes(predicate.type) &&
     addition &&
     addition.type === "else" &&
     [stmts, addition.body[0]].every(canTernaryStmts)
@@ -189,7 +188,7 @@ const canTernary = path => {
 };
 
 // A normalized print function for both `if` and `unless` nodes.
-const printConditional = keyword => (path, { inlineConditionals }, print) => {
+const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
   if (canTernary(path)) {
     let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
       printTernaryClauses(
@@ -230,7 +229,12 @@ const printConditional = keyword => (path, { inlineConditionals }, print) => {
   // know for sure that it doesn't impact the body of the conditional, so we
   // have to default to the block form.
   if (containsAssignment(predicate)) {
-    return makeSingleBlockForm(keyword, path, print);
+    return concat([
+      `${keyword} `,
+      align(keyword.length + 1, path.call(print, "body", 0)),
+      indent(concat([hardline, path.call(print, "body", 1)])),
+      concat([hardline, "end"])
+    ]);
   }
 
   return printSingle(keyword)(path, { inlineConditionals }, print);

data/src/nodes/hashes.js

@@ -12,7 +12,7 @@ const { prefix, skipAssignIndent } = require("../utils");
 const nodeDive = (node, steps) => {
   let current = node;
 
-  steps.forEach(step => {
+  steps.forEach((step) => {
     current = current[step];
   });
 
@@ -29,7 +29,7 @@ const nodeDive = (node, steps) => {
 //
 // This function represents that check, as it determines if it can convert the
 // symbol node into a hash label.
-const isValidHashLabel = symbolLiteral => {
+const isValidHashLabel = (symbolLiteral) => {
   const label = symbolLiteral.body[0].body[0].body;
   return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
 };

data/src/nodes/hooks.js

@@ -1,6 +1,6 @@
 const { concat, group, indent, line } = require("../prettier");
 
-const printHook = name => (path, opts, print) =>
+const printHook = (name) => (path, opts, print) =>
   group(
     concat([
       `${name} {`,

data/src/nodes/ints.js

@@ -11,7 +11,7 @@ module.exports = {
     // If the number is a base 10 number, is sufficiently large, and is not
     // already formatted with underscores, then add them in in between the
     // numbers every three characters starting from the right.
-    if (!body.startsWith("0") && body.length >= 4 && !body.includes("_")) {
+    if (!body.startsWith("0") && body.length >= 5 && !body.includes("_")) {
       return `  ${body}`
         .slice((body.length + 2) % 3)
         .match(/.{3}/g)

data/src/nodes/lambdas.js

@@ -21,7 +21,7 @@ module.exports = {
       paramsConcat = path.call(print, "body", 0, "body", 0);
     }
 
-    const noParams = params.body.every(type => !type);
+    const noParams = params.body.every((type) => !type);
     const inlineLambda = concat([
       "->",
       noParams ? "" : concat(["(", paramsConcat, ")"]),

data/src/nodes/loops.js

@@ -10,6 +10,22 @@ const {
 const { containsAssignment } = require("../utils");
 
 const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
+  const [_predicate, statements] = path.getValue().body;
+
+  // If the only statement inside this while loop is a void statement, then we
+  // can shorten to just displaying the predicate and then a semicolon.
+  if (statements.body.length === 1 && statements.body[0].type === "void_stmt") {
+    return group(
+      concat([
+        keyword,
+        " ",
+        path.call(print, "body", 0),
+        ifBreak(softline, "; "),
+        "end"
+      ])
+    );
+  }
+
   let inlineParts = [
     path.call(print, "body", 1),
     ` ${keyword} `,

data/src/nodes/methods.js

@@ -9,7 +9,7 @@ const {
 } = require("../prettier");
 const { first, literal } = require("../utils");
 
-const printMethod = offset => (path, opts, print) => {
+const printMethod = (offset) => (path, opts, print) => {
   const [_name, params, body] = path.getValue().body.slice(offset);
   const declaration = ["def "];
 
@@ -21,7 +21,7 @@ const printMethod = offset => (path, opts, print) => {
 
   // In case there are no parens but there are arguments
   const parens =
-    params.type === "params" && params.body.some(paramType => paramType);
+    params.type === "params" && params.body.some((paramType) => paramType);
 
   declaration.push(
     path.call(print, "body", offset),

data/src/nodes/operators.js

@@ -7,10 +7,18 @@ module.exports = {
 
     return group(
       concat([
-        concat([path.call(print, "body", 0), useNoSpace ? "" : " "]),
-        operator,
+        group(path.call(print, "body", 0)),
         indent(
-          concat([useNoSpace ? softline : line, path.call(print, "body", 2)])
+          concat([
+            useNoSpace ? "" : " ",
+            group(
+              concat([
+                operator,
+                useNoSpace ? softline : line,
+                path.call(print, "body", 2)
+              ])
+            )
+          ])
         )
       ])
     );

data/src/nodes/params.js

@@ -1,6 +1,7 @@
 const { concat, group, join, line } = require("../prettier");
+const { literal } = require("../utils");
 
-const printGenericRestParam = symbol => (path, opts, print) =>
+const printGenericRestParam = (symbol) => (path, opts, print) =>
   path.getValue().body[0]
     ? concat([symbol, path.call(print, "body", 0)])
     : symbol;
@@ -53,7 +54,7 @@ const printParams = (path, opts, print) => {
   }
 
   if (kwargRest) {
-    parts.push(path.call(print, "body", 5));
+    parts.push(kwargRest === "nil" ? "**nil" : path.call(print, "body", 5));
   }
 
   if (block) {
@@ -79,6 +80,7 @@ const paramError = () => {
 };
 
 module.exports = {
+  args_forward: literal("..."),
   kwrest_param: printGenericRestParam("**"),
   rest_param: printGenericRestParam("*"),
   params: printParams,

data/src/nodes/regexp.js

@@ -7,7 +7,7 @@ module.exports = {
     const [contents, ending] = path.map(print, "body");
 
     const useBraces = contents.some(
-      content => typeof content === "string" && content.includes("/")
+      (content) => typeof content === "string" && content.includes("/")
     );
     const parts = [useBraces ? "%r{" : "/"]
       .concat(contents)

data/src/nodes/rescue.js

@@ -53,7 +53,11 @@ module.exports = {
       parts.push(" StandardError");
     }
 
-    parts.push(indent(concat([hardline, path.call(print, "body", 2)])));
+    const rescueBody = path.call(print, "body", 2);
+
+    if (rescueBody.parts.length > 0) {
+      parts.push(indent(concat([hardline, rescueBody])));
+    }
 
     // This is the next clause on the `begin` statement, either another
     // `rescue`, and `ensure`, or an `else` clause.

data/src/nodes/return.js

@@ -9,6 +9,16 @@ const {
 } = require("../prettier");
 const { literal } = require("../utils");
 
+// You can't skip the parentheses if you have the `and` or `or` operator,
+// because they have low enough operator precedence that you need to explicitly
+// keep them in there.
+const canSkipParens = (args) => {
+  const statement = args.body[0].body[0].body[0];
+  return (
+    statement.type !== "binary" || !["and", "or"].includes(statement.body[1])
+  );
+};
+
 const printReturn = (path, opts, print) => {
   let args = path.getValue().body[0].body[0];
   let steps = ["body", 0, "body", 0];
@@ -20,17 +30,19 @@ const printReturn = (path, opts, print) => {
   // If the body of the return contains parens, then just skip directly to the
   // content of the parens so that we can skip printing parens if we don't
   // want them.
-  if (args.body[0] && args.body[0].type === "paren") {
+  if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
     args = args.body[0].body[0];
     steps = steps.concat("body", 0, "body", 0);
   }
 
-  // If we're returning an array literal that isn't a special array, then we
-  // want to grab the arguments so that we can print them out as if they were
-  // normal return arguments.
+  // If we're returning an array literal that isn't a special array, single
+  // element array, or an empty array, then we want to grab the arguments so
+  // that we can print them out as if they were normal return arguments.
   if (
     args.body[0] &&
     args.body[0].type === "array" &&
+    args.body[0].body[0] &&
+    args.body[0].body[0].body.length > 1 &&
     ["args", "args_add_star"].includes(args.body[0].body[0].type)
   ) {
     steps = steps.concat("body", 0, "body", 0);

data/src/nodes/strings.js

@@ -7,39 +7,31 @@ const {
   softline,
   join
 } = require("../prettier");
+
 const { concatBody, empty, makeList, prefix, surround } = require("../utils");
-const escapePattern = require("../escapePattern");
 
 // 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 =>
+const isQuoteLocked = (string) =>
   string.body.some(
-    part =>
+    (part) =>
       part.type === "@tstring_content" &&
-      (escapePattern.test(part.body) || part.body.includes("#{"))
+      (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 =>
+const isSingleQuotable = (string) =>
   string.body.every(
-    part => part.type === "@tstring_content" && !part.body.includes("'")
+    (part) => part.type === "@tstring_content" && !part.body.includes("'")
   );
 
-const getStringQuote = (string, preferSingleQuotes) => {
-  if (isQuoteLocked(string)) {
-    return string.quote;
-  }
-
-  return preferSingleQuotes && isSingleQuotable(string) ? "'" : '"';
-};
-
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
-const makeString = (content, enclosingQuote, originalQuote) => {
+const normalizeQuotes = (content, enclosingQuote, originalQuote) => {
   const replaceOther = ["'", '"'].includes(originalQuote);
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
 
@@ -62,51 +54,24 @@ const makeString = (content, enclosingQuote, originalQuote) => {
   });
 };
 
-// The `parts` argument that comes into this function is an array of either
-// printed embedded expressions or plain strings (that themselves can contain
-// newlines). What we want to return is an array where each element represents a
-// line in the original text. So we end up tracking every line as we go and
-// pushing onto a `currentLine` variable, then when we hit a new line we push
-// the current line onto the `lines` variable until we've used up every part.
-const makeHeredocLines = parts => {
-  let lines = [];
-  let currentLine = [];
-
-  parts.forEach(part => {
-    if (part.type === "group" || !part.includes("\n")) {
-      // In this case we've either hit an embedded expression or the piece of
-      // the current line that we're looking at is in the middle of two of them,
-      // so we just push onto the current line and continue on.
-      currentLine.push(part);
-      return;
-    }
-
-    let splits = part.split("\n");
-    if (splits[splits.length - 1] === "") {
-      // If a line ends with a newline, then we end up with an empty string at
-      // the end of the splits, we just pop it off here since we'll handle the
-      // newlines later.
-      splits = splits.slice(0, -1);
-    }
-
-    if (currentLine.length > 0) {
-      lines.push(concat(currentLine.concat(splits[0])));
-      currentLine = [];
-    } else {
-      lines.push(splits[0]);
-    }
+const quotePairs = {
+  "(": ")",
+  "[": "]",
+  "{": "}",
+  "<": ">"
+};
 
-    if (splits.length > 1) {
-      lines = lines.concat(splits.slice(1, -1));
-      currentLine.push(splits[splits.length - 1]);
-    }
-  });
+const getClosingQuote = (quote) => {
+  if (!quote.startsWith("%")) {
+    return quote;
+  }
 
-  if (currentLine.length > 0) {
-    lines = lines.concat(currentLine);
+  const boundary = /%q?(.)/.exec(quote)[1];
+  if (boundary in quotePairs) {
+    return quotePairs[boundary];
   }
 
-  return lines;
+  return boundary;
 };
 
 module.exports = {
@@ -121,21 +86,24 @@ module.exports = {
     return body.length === 2 ? concat([quote, body.slice(1), quote]) : body;
   },
   dyna_symbol: (path, opts, print) => {
-    const { quote } = path.getValue().body[0];
+    const { quote } = path.getValue();
 
     return concat([":", quote, concat(path.call(print, "body", 0)), quote]);
   },
   heredoc: (path, opts, print) => {
-    const { beging, ending } = path.getValue();
-    const lines = makeHeredocLines(path.map(print, "body"));
-
-    return concat([
-      beging,
-      literalline,
-      join(literalline, lines),
-      literalline,
-      ending
-    ]);
+    const { beging, body, ending } = path.getValue();
+
+    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);
+      }
+
+      // In this case, the part of the string is just regular string content
+      return join(literalline, part.body.split("\n"));
+    });
+
+    return concat([beging, literalline, concat(parts), ending]);
   },
   string: makeList,
   string_concat: (path, opts, print) =>
@@ -162,7 +130,8 @@ module.exports = {
     );
   },
   string_literal: (path, { preferSingleQuotes }, print) => {
-    const string = path.getValue().body[0];
+    const stringLiteral = path.getValue();
+    const string = stringLiteral.body[0];
 
     // If this string is actually a heredoc, bail out and return to the print
     // function for heredocs
@@ -176,20 +145,28 @@ module.exports = {
       return preferSingleQuotes ? "''" : '""';
     }
 
-    const quote = getStringQuote(string, preferSingleQuotes);
-    const parts = [];
+    // Determine the quote that should enclose the new string
+    let quote;
+    if (isQuoteLocked(string)) {
+      ({ quote } = stringLiteral);
+    } else {
+      quote = preferSingleQuotes && isSingleQuotable(string) ? "'" : '"';
+    }
 
-    string.body.forEach((part, index) => {
-      if (part.type === "@tstring_content") {
-        // In this case, the part of the string is just regular string content
-        parts.push(makeString(part.body, quote, string.quote));
-      } else {
+    const parts = string.body.map((part, index) => {
+      if (part.type !== "@tstring_content") {
         // In this case, the part of the string is an embedded expression
-        parts.push(path.call(print, "body", 0, "body", index));
+        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([quote]));
+    return concat([quote].concat(parts).concat(getClosingQuote(quote)));
   },
   symbol: prefix(":"),
   symbol_literal: concatBody,