prettier 1.2.3 → 1.5.0

data/src/ruby/nodes/commands.js

@@ -105,8 +105,13 @@ function printCommandCall(path, opts, print) {
   let breakDoc;
 
   if (hasTernaryArg(node.body[3])) {
-    parts.push("(");
-    breakDoc = parts.concat(indent(concat([softline, argDocs])), softline, ")");
+    breakDoc = parts.concat(
+      "(",
+      indent(concat([softline, argDocs])),
+      softline,
+      ")"
+    );
+    parts.push(" ");
   } else if (skipArgsAlign(path)) {
     parts.push(" ");
     breakDoc = parts.concat(argDocs);

data/src/ruby/nodes/conditionals.js

@@ -219,7 +219,7 @@ const printConditional = (keyword) => (path, { rubyModifier }, print) => {
 
   // If the body of the conditional is empty, then we explicitly have to use the
   // block form.
-  if (isEmptyStmts(statements) && !statements.body[0].comments) {
+  if (isEmptyStmts(statements)) {
     return concat([
       `${keyword} `,
       align(keyword.length + 1, path.call(print, "body", 0)),

data/src/ruby/nodes/hashes.js

@@ -6,6 +6,7 @@ const {
   join,
   line
 } = require("../../prettier");
+
 const {
   getTrailingComma,
   printEmptyCollection,
@@ -89,6 +90,13 @@ function printAssocNew(path, opts, print) {
   const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
   const valueDoc = path.call(print, "body", 1);
 
+  // If we're printing a child hash then we want it to break along with its
+  // parent hash, so we don't group the parts.
+  if (valueNode.type === "hash") {
+    parts.push(" ", valueDoc);
+    return concat(parts);
+  }
+
   if (!skipAssignIndent(valueNode) || keyNode.comments) {
     parts.push(indent(concat([line, valueDoc])));
   } else {
@@ -125,20 +133,26 @@ function printHash(path, opts, print) {
     return printEmptyCollection(path, opts, "{", "}");
   }
 
-  return group(
-    concat([
-      "{",
-      indent(
-        concat([
-          line,
-          path.call(print, "body", 0),
-          getTrailingComma(opts) ? ifBreak(",", "") : ""
-        ])
-      ),
-      line,
-      "}"
-    ])
-  );
+  let hashDoc = concat([
+    "{",
+    indent(
+      concat([
+        line,
+        path.call(print, "body", 0),
+        getTrailingComma(opts) ? ifBreak(",", "") : ""
+      ])
+    ),
+    line,
+    "}"
+  ]);
+
+  // If we're inside another hash, then we don't want to group our contents
+  // because we want this hash to break along with its parent hash.
+  if (path.getParentNode().type === "assoc_new") {
+    return hashDoc;
+  }
+
+  return group(hashDoc);
 }
 
 module.exports = {

data/src/ruby/nodes/hooks.js

@@ -1,5 +1,4 @@
 const { concat, group, indent, line } = require("../../prettier");
-const { isEmptyStmts } = require("../../utils");
 
 // The `BEGIN` and `END` keywords are used to hook into the Ruby process. Any
 // `BEGIN` blocks are executed right when the process starts up, and the `END`
@@ -17,24 +16,15 @@ const { isEmptyStmts } = require("../../utils");
 // nodes contain one child which is a `stmts` node.
 function printHook(name) {
   return function printHookWithName(path, opts, print) {
-    const stmtsNode = path.getValue().body[1];
-    const printedStmts = path.call(print, "body", 1);
-
-    const parts = [
-      name,
-      " ",
-      path.call(print, "body", 0),
-      indent(concat([line, printedStmts])),
-      concat([line, "}"])
-    ];
-
-    // If there are no statements but there are comments, then we want to skip
-    // printing the newline so that we don't end up with multiple spaces.
-    if (isEmptyStmts(stmtsNode) && stmtsNode.comments) {
-      parts[1] = indent(printedStmts);
-    }
-
-    return group(concat(parts));
+    return group(
+      concat([
+        name,
+        " ",
+        path.call(print, "body", 0),
+        indent(concat([line, path.call(print, "body", 1)])),
+        concat([line, "}"])
+      ])
+    );
   };
 }
 

data/src/ruby/nodes/loops.js

@@ -10,7 +10,7 @@ const {
   softline
 } = require("../../prettier");
 
-const { containsAssignment } = require("../../utils");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
 const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 function printLoop(keyword, modifier) {
@@ -19,17 +19,11 @@ function printLoop(keyword, modifier) {
 
     // 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 (
-      stmts.body.length === 1 &&
-      stmts.body[0].type === "void_stmt" &&
-      !stmts.body[0].comments
-    ) {
+    if (isEmptyStmts(stmts)) {
       return group(
         concat([
-          keyword,
-          " ",
-          path.call(print, "body", 0),
-          ifBreak(softline, "; "),
+          group(concat([keyword, " ", path.call(print, "body", 0)])),
+          hardline,
           "end"
         ])
       );

data/src/ruby/nodes/methods.js

@@ -1,8 +1,9 @@
 const { concat, group, hardline, indent, line } = require("../../prettier");
+const { isEmptyBodyStmt } = require("../../utils");
 
 function printMethod(offset) {
   return function printMethodWithOffset(path, opts, print) {
-    const [_name, params, body] = path.getValue().body.slice(offset);
+    const [_name, params, bodystmt] = path.getValue().body.slice(offset);
     const declaration = ["def "];
 
     // In this case, we're printing a method that's defined as a singleton, so
@@ -24,16 +25,8 @@ function printMethod(offset) {
       parens ? ")" : ""
     );
 
-    // If the body is empty, we can replace with a ;
-    const stmts = body.body[0].body;
-
-    if (
-      !body.body.slice(1).some((node) => node) &&
-      stmts.length === 1 &&
-      stmts[0].type === "void_stmt" &&
-      !stmts[0].comments
-    ) {
-      return group(concat(declaration.concat(["; end"])));
+    if (isEmptyBodyStmt(bodystmt)) {
+      return group(concat(declaration.concat("; end")));
     }
 
     return group(
@@ -47,15 +40,13 @@ function printMethod(offset) {
 }
 
 function printSingleLineMethod(path, opts, print) {
-  let paramsNode = path.getValue().body[1];
+  let parensNode = path.getValue().body[1];
   let paramsDoc = "";
 
-  if (paramsNode) {
-    if (paramsNode.body[0].type === "params") {
-      paramsNode = paramsNode.body[0];
-    }
+  if (parensNode) {
+    const paramsNode = parensNode.body[0];
 
-    if (paramsNode.type === "params" && paramsNode.body.some((type) => type)) {
+    if (paramsNode.body.some((type) => type)) {
       paramsDoc = path.call(print, "body", 1);
     }
   }

data/src/ruby/nodes/params.js

@@ -29,18 +29,22 @@ function printParams(path, opts, print) {
   let parts = [];
 
   if (reqs) {
-    parts = parts.concat(path.map(print, "body", 0));
+    path.each(
+      (reqPath) => {
+        // For some very strange reason, if you have a comment attached to a
+        // rest_param, it shows up here in the list of required params.
+        if (reqPath.getValue().type !== "rest_param") {
+          parts.push(print(reqPath));
+        }
+      },
+      "body",
+      0
+    );
   }
 
   if (optls) {
     parts = parts.concat(
-      optls.map((_, index) =>
-        concat([
-          path.call(print, "body", 1, index, 0),
-          " = ",
-          path.call(print, "body", 1, index, 1)
-        ])
-      )
+      path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1)
     );
   }
 
@@ -54,12 +58,16 @@ function printParams(path, opts, print) {
 
   if (kwargs) {
     parts = parts.concat(
-      kwargs.map(([, value], index) => {
-        if (!value) {
-          return path.call(print, "body", 4, index, 0);
-        }
-        return group(join(" ", path.map(print, "body", 4, index)));
-      })
+      path.map(
+        (kwargPath) => {
+          if (!kwargPath.getValue()[1]) {
+            return kwargPath.call(print, 0);
+          }
+          return group(join(" ", kwargPath.map(print)));
+        },
+        "body",
+        4
+      )
     );
   }
 

data/src/ruby/nodes/patterns.js

@@ -1,4 +1,5 @@
 const {
+  align,
   concat,
   group,
   hardline,
@@ -74,7 +75,7 @@ function printHshPtn(path, opts, print) {
   const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
   let args = [];
 
-  if (keyValuePairs) {
+  if (keyValuePairs.length > 0) {
     const printPair = (pairPath) => {
       const parts = [pairPath.call(print, 0)];
 
@@ -116,10 +117,13 @@ function printHshPtn(path, opts, print) {
 function printIn(path, opts, print) {
   const parts = [
     "in ",
-    path.call(
-      (valuePath) => printPatternArg(valuePath, opts, print),
-      "body",
-      0
+    align(
+      "in ".length,
+      path.call(
+        (valuePath) => printPatternArg(valuePath, opts, print),
+        "body",
+        0
+      )
     ),
     indent(concat([hardline, path.call(print, "body", 1)]))
   ];

data/src/ruby/nodes/rescue.js

@@ -26,28 +26,10 @@ function printEnsure(path, opts, print) {
 }
 
 function printRescue(path, opts, print) {
-  const [exception, variable, _stmts, addition] = path.getValue().body;
   const parts = ["rescue"];
 
-  if (exception || variable) {
-    if (exception) {
-      if (Array.isArray(exception)) {
-        // In this case, it's actually only the one exception (it's an array
-        // of length 1).
-        parts.push(" ", path.call(print, "body", 0, 0));
-      } else {
-        // Here we have multiple exceptions from which we're rescuing, so we
-        // need to align them and join them together.
-        const joiner = concat([",", line]);
-        const exceptions = group(join(joiner, path.call(print, "body", 0)));
-
-        parts.push(" ", align("rescue ".length, exceptions));
-      }
-    }
-
-    if (variable) {
-      parts.push(" => ", path.call(print, "body", 1));
-    }
+  if (path.getValue().body[0]) {
+    parts.push(align("rescue ".length, path.call(print, "body", 0)));
   } else {
     // If you don't specify an error to rescue in a `begin/rescue` block, then
     // implicitly you're rescuing from `StandardError`. In this case, we're
@@ -55,16 +37,40 @@ function printRescue(path, opts, print) {
     parts.push(" StandardError");
   }
 
-  const rescueBody = path.call(print, "body", 2);
+  const bodystmt = path.call(print, "body", 1);
 
-  if (rescueBody.parts.length > 0) {
-    parts.push(indent(concat([hardline, rescueBody])));
+  if (bodystmt.parts.length > 0) {
+    parts.push(indent(concat([hardline, bodystmt])));
   }
 
   // This is the next clause on the `begin` statement, either another
   // `rescue`, and `ensure`, or an `else` clause.
-  if (addition) {
-    parts.push(concat([hardline, path.call(print, "body", 3)]));
+  if (path.getValue().body[2]) {
+    parts.push(concat([hardline, path.call(print, "body", 2)]));
+  }
+
+  return group(concat(parts));
+}
+
+// This is a container node that we're adding into the AST that isn't present in
+// Ripper solely so that we have a nice place to attach inline comments.
+function printRescueEx(path, opts, print) {
+  const [exception, variable] = path.getValue().body;
+  const parts = [];
+
+  if (exception) {
+    let exceptionDoc = path.call(print, "body", 0);
+
+    if (Array.isArray(exceptionDoc)) {
+      const joiner = concat([",", line]);
+      exceptionDoc = group(join(joiner, exceptionDoc));
+    }
+
+    parts.push(" ", exceptionDoc);
+  }
+
+  if (variable) {
+    parts.push(" => ", path.call(print, "body", 1));
   }
 
   return group(concat(parts));
@@ -89,6 +95,7 @@ module.exports = {
   ensure: printEnsure,
   redo: literal("redo"),
   rescue: printRescue,
+  rescue_ex: printRescueEx,
   rescue_mod: printRescueMod,
   retry: literal("retry")
 };

data/src/ruby/nodes/return.js

@@ -41,10 +41,6 @@ const printReturn = (path, opts, print) => {
   let args = path.getValue().body[0].body[0];
   let steps = ["body", 0, "body", 0];
 
-  if (!args) {
-    return "return";
-  }
-
   if (args.body.length === 1) {
     // 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

data/src/ruby/nodes/statements.js

@@ -12,15 +12,13 @@ const {
   trim
 } = require("../../prettier");
 
+const { isEmptyStmts } = require("../../utils");
+
 function printBodyStmt(path, opts, print) {
   const [stmts, rescue, elseClause, ensure] = path.getValue().body;
   const parts = [];
 
-  if (
-    stmts.body.length > 1 ||
-    stmts.body[0].type != "void_stmt" ||
-    stmts.body[0].comments
-  ) {
+  if (!isEmptyStmts(stmts)) {
     parts.push(path.call(print, "body", 0));
   }
 
@@ -30,6 +28,7 @@ function printBodyStmt(path, opts, print) {
 
   if (elseClause) {
     // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+    /* istanbul ignore next */
     const stmts =
       elseClause.type === "else"
         ? path.call(print, "body", 2, "body", 0)
@@ -69,11 +68,7 @@ function printParen(path, opts, print) {
   }
 
   return group(
-    concat([
-      "(",
-      indent(concat([softline, contentDoc])),
-      concat([softline, ")"])
-    ])
+    concat(["(", indent(concat([softline, contentDoc])), softline, ")"])
   );
 }
 
@@ -82,6 +77,9 @@ module.exports = {
     const { body } = path.getValue();
     return concat([trim, "__END__", literalline, body]);
   },
+  "@comment"(path, opts, _print) {
+    return opts.printer.printComment(path);
+  },
   bodystmt: printBodyStmt,
   paren: printParen,
   program: (path, opts, print) =>
@@ -123,12 +121,12 @@ module.exports = {
       if (lineNo === null) {
         parts.push(printed);
       } else if (
-        stmt.start - lineNo > 1 ||
+        stmt.sl - lineNo > 1 ||
         [stmt.type, stmts[index - 1].type].includes("access_ctrl")
       ) {
         parts.push(hardline, hardline, printed);
       } else if (
-        stmt.start !== lineNo ||
+        stmt.sl !== lineNo ||
         path.getParentNode().type !== "string_embexpr"
       ) {
         parts.push(hardline, printed);
@@ -136,7 +134,7 @@ module.exports = {
         parts.push("; ", printed);
       }
 
-      lineNo = stmt.end;
+      lineNo = stmt.el;
     });
 
     return concat(parts);