prettier 0.21.0 → 1.0.1

data/src/nodes/assign.js

@@ -1,39 +1,39 @@
 const { concat, group, indent, join, line } = require("../prettier");
-const { concatBody, first, skipAssignIndent } = require("../utils");
+const { first, skipAssignIndent } = require("../utils");
 
-module.exports = {
-  assign: (path, opts, print) => {
-    const [printedTarget, printedValue] = path.map(print, "body");
-    let adjustedValue = printedValue;
+function printAssign(path, opts, print) {
+  const [_targetNode, valueNode] = path.getValue().body;
+  const [targetDoc, valueDoc] = path.map(print, "body");
+
+  let rightSideDoc = valueDoc;
+
+  // If the right side of this assignment is a multiple assignment, then we need
+  // to join it together with commas.
+  if (["mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
+    rightSideDoc = group(join(concat([",", line]), valueDoc));
+  }
 
-    if (
-      ["mrhs_add_star", "mrhs_new_from_args"].includes(
-        path.getValue().body[1].type
-      )
-    ) {
-      adjustedValue = group(join(concat([",", line]), printedValue));
-    }
+  if (skipAssignIndent(valueNode)) {
+    return group(concat([targetDoc, " = ", rightSideDoc]));
+  }
 
-    if (skipAssignIndent(path.getValue().body[1])) {
-      return group(concat([printedTarget, " = ", adjustedValue]));
-    }
+  return group(concat([targetDoc, " =", indent(concat([line, rightSideDoc]))]));
+}
 
-    return group(
-      concat([printedTarget, " =", indent(concat([line, adjustedValue]))])
-    );
-  },
-  assign_error: (_path, _opts, _print) => {
-    throw new Error("Can't set variable");
-  },
-  opassign: (path, opts, print) =>
-    group(
-      concat([
-        path.call(print, "body", 0),
-        " ",
-        path.call(print, "body", 1),
-        indent(concat([line, path.call(print, "body", 2)]))
-      ])
-    ),
-  var_field: concatBody,
+function printOpAssign(path, opts, print) {
+  return group(
+    concat([
+      path.call(print, "body", 0),
+      " ",
+      path.call(print, "body", 1),
+      indent(concat([line, path.call(print, "body", 2)]))
+    ])
+  );
+}
+
+module.exports = {
+  assign: printAssign,
+  opassign: printOpAssign,
+  var_field: first,
   var_ref: first
 };

data/src/nodes/blocks.js

@@ -16,7 +16,11 @@ const printBlock = (braces) => (path, opts, print) => {
     statements.type === "stmts" ? statements.body : statements.body[0].body;
 
   let doBlockBody = "";
-  if (stmts.length !== 1 || stmts[0].type !== "void_stmt") {
+  if (
+    stmts.length !== 1 ||
+    stmts[0].type !== "void_stmt" ||
+    stmts[0].comments
+  ) {
     doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
   }
 
@@ -37,8 +41,9 @@ const printBlock = (braces) => (path, opts, print) => {
   // We can hit this next pattern if within the block the only statement is a
   // comment.
   if (
-    stmts.length > 1 &&
-    stmts.filter((stmt) => stmt.type !== "@comment").length === 1
+    stmts.length === 1 &&
+    stmts[0].type === "void_stmt" &&
+    stmts[0].comments
   ) {
     return concat([breakParent, doBlock]);
   }

data/src/nodes/calls.js

@@ -1,69 +1,146 @@
-const { concat, group, indent, literalline, softline } = require("../prettier");
+const {
+  concat,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  softline
+} = require("../prettier");
+const { first, makeCall, noIndent } = require("../utils");
+
 const toProc = require("../toProc");
-const { concatBody, first, makeCall } = require("../utils");
 
-const noIndent = ["array", "hash", "if", "method_add_block", "xstring_literal"];
+const chained = ["call", "method_add_arg", "method_add_block"];
 
-module.exports = {
-  call: (path, opts, print) => {
-    const [receiverNode, _operatorNode, messageNode] = path.getValue().body;
-
-    const printedReceiver = path.call(print, "body", 0);
-    const printedOperator = makeCall(path, opts, print);
-
-    // You can call lambdas with a special syntax that looks like func.(*args).
-    // In this case, "call" is returned for the 3rd child node.
-    const printedMessage =
-      messageNode === "call" ? messageNode : path.call(print, "body", 2);
-
-    // If we have a heredoc as a receiver, then we need to move the operator and
-    // the message up to start of the heredoc declaration, as in:
-    //
-    //     <<~TEXT.strip
-    //       content
-    //     TEXT
-    if (receiverNode.type === "heredoc") {
-      return concat([
-        receiverNode.beging,
-        printedOperator,
-        printedMessage,
-        literalline,
-        concat(path.map(print, "body", 0, "body")),
-        receiverNode.ending
-      ]);
-    }
+function printCall(path, opts, print) {
+  const node = path.getValue();
+  const [receiverNode, _operatorNode, messageNode] = node.body;
 
-    // For certain left sides of the call nodes, we want to attach directly to
-    // the } or end.
-    if (noIndent.includes(receiverNode.type)) {
-      return concat([printedReceiver, printedOperator, printedMessage]);
-    }
+  const receiverDoc = path.call(print, "body", 0);
+  const operatorDoc = makeCall(path, opts, print);
+
+  // You can call lambdas with a special syntax that looks like func.(*args).
+  // In this case, "call" is returned for the 3rd child node. We don't alter
+  // call syntax so if `call` is implicit, we don't print it out.
+  const messageDoc = messageNode === "call" ? "" : path.call(print, "body", 2);
+
+  // The right side of the call node, as in everything including the operator
+  // and beyond.
+  const rightSideDoc = concat([
+    receiverNode.comments ? hardline : softline,
+    operatorDoc,
+    messageDoc
+  ]);
+
+  // Get a reference to the parent node so we can check if we're inside a chain
+  const parentNode = path.getParentNode();
+
+  // If our parent node is a chained node then we're not going to group the
+  // right side of the expression, as we want to have a nice multi-line layout.
+  if (chained.includes(parentNode.type)) {
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
+  }
 
-    return group(
-      concat([
-        printedReceiver,
-        group(indent(concat([softline, printedOperator, printedMessage])))
-      ])
+  // If we're at the top of a chain, then we're going to print out a nice
+  // multi-line layout if this doesn't break into multiple lines.
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
+    return ifBreak(
+      group(indent(concat(node.breakDoc.concat(rightSideDoc)))),
+      concat([receiverDoc, group(rightSideDoc)])
     );
-  },
-  fcall: concatBody,
-  method_add_arg: (path, opts, print) => {
-    const [method, args] = path.map(print, "body");
-    const argNode = path.getValue().body[1];
-
-    // This case will ONLY be hit if we can successfully turn the block into a
-    // to_proc call. In that case, we just explicitly add the parens around it.
-    if (argNode.type === "args" && args.length > 0) {
-      return concat([method, "("].concat(args).concat(")"));
-    }
+  }
+
+  // For certain left sides of the call nodes, we want to attach directly to
+  // the } or end.
+  if (noIndent.includes(receiverNode.type)) {
+    return concat([receiverDoc, operatorDoc, messageDoc]);
+  }
+
+  return group(concat([receiverDoc, group(indent(rightSideDoc))]));
+}
+
+function printMethodAddArg(path, opts, print) {
+  const node = path.getValue();
+  const argNode = node.body[1];
+
+  const [methodDoc, argsDoc] = path.map(print, "body");
+
+  // You can end up here if you have a method with a ? ending, presumably
+  // because the parser knows that it cannot be a local variable.
+  if (argsDoc.length === 0) {
+    return methodDoc;
+  }
+
+  // This case will ONLY be hit if we can successfully turn the block into a
+  // to_proc call. In that case, we just explicitly add the parens around it.
+  if (argNode.type === "args" && argsDoc.length > 0) {
+    return concat([methodDoc, "("].concat(argsDoc).concat(")"));
+  }
+
+  // Get a reference to the parent node so we can check if we're inside a chain
+  const parentNode = path.getParentNode();
 
-    return concat([method, args]);
-  },
-  method_add_block: (path, opts, print) => {
-    const [method, block] = path.getValue().body;
-    const proc = toProc(path, opts, block);
+  // If our parent node is a chained node then we're not going to group the
+  // right side of the expression, as we want to have a nice multi-line layout.
+  if (chained.includes(parentNode.type)) {
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
+  }
 
-    if (proc && method.type === "call") {
+  // If we're at the top of a chain, then we're going to print out a nice
+  // multi-line layout if this doesn't break into multiple lines.
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
+    return ifBreak(
+      group(indent(concat(node.breakDoc.concat(argsDoc)))),
+      concat([methodDoc, argsDoc])
+    );
+  }
+
+  return concat([methodDoc, argsDoc]);
+}
+
+// Sorbet type annotations look like the following:
+//
+//     {method_add_block
+//       [{method_add_arg
+//          [{fcall
+//             [{@ident "sig"}]},
+//           {args []}]},
+//        {brace_block [nil, {stmts}]}}]}
+//
+function isSorbetTypeAnnotation(node) {
+  const [callNode, blockNode] = node.body;
+
+  return (
+    callNode.type === "method_add_arg" &&
+    callNode.body[0].type === "fcall" &&
+    callNode.body[0].body[0].body === "sig" &&
+    callNode.body[1].type === "args" &&
+    callNode.body[1].body.length === 0 &&
+    blockNode.type === "brace_block"
+  );
+}
+
+function printMethodAddBlock(path, opts, print) {
+  const node = path.getValue();
+
+  const [callNode, blockNode] = node.body;
+  const [callDoc, blockDoc] = path.map(print, "body");
+
+  // Very special handling here for sorbet type annotations. They look like Ruby
+  // code, but they're not actually Ruby code, so we're not going to mess with
+  // them at all.
+  if (isSorbetTypeAnnotation(node)) {
+    return opts.originalText.slice(opts.locStart(node), opts.locEnd(node));
+  }
+
+  // Don't bother trying to do any kind of fancy toProc transform if the option
+  // is disabled.
+  if (opts.rubyToProc) {
+    const proc = toProc(path, blockNode);
+
+    if (proc && callNode.type === "call") {
       return group(
         concat([
           path.call(print, "body", 0),
@@ -77,8 +154,34 @@ module.exports = {
     if (proc) {
       return path.call(print, "body", 0);
     }
+  }
+
+  // Get a reference to the parent node so we can check if we're inside a chain
+  const parentNode = path.getParentNode();
 
-    return concat(path.map(print, "body"));
-  },
+  // If our parent node is a chained node then we're not going to group the
+  // right side of the expression, as we want to have a nice multi-line layout.
+  if (chained.includes(parentNode.type)) {
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [callDoc]).concat(blockDoc);
+  }
+
+  // If we're at the top of a chain, then we're going to print out a nice
+  // multi-line layout if this doesn't break into multiple lines.
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
+    return ifBreak(
+      group(indent(concat(node.breakDoc.concat(blockDoc)))),
+      concat([callDoc, blockDoc])
+    );
+  }
+
+  return concat([callDoc, blockDoc]);
+}
+
+module.exports = {
+  call: printCall,
+  fcall: first,
+  method_add_arg: printMethodAddArg,
+  method_add_block: printMethodAddBlock,
   vcall: first
 };

data/src/nodes/case.js

@@ -28,13 +28,17 @@ module.exports = {
     // The `fill` builder command expects an array of docs alternating with
     // line breaks. This is so it can loop through and determine where to break.
     const preds = fill(
-      path
-        .call(print, "body", 0)
-        .reduce(
-          (accum, pred, index) =>
-            index === 0 ? [pred] : accum.concat([",", line, pred]),
-          null
-        )
+      path.call(print, "body", 0).reduce((accum, pred, index) => {
+        if (index === 0) {
+          return [pred];
+        }
+
+        // Pull off the last element and make it concat with a comma so that
+        // we can maintain alternating lines and docs.
+        return accum
+          .slice(0, -1)
+          .concat([concat([accum[accum.length - 1], ","]), line, pred]);
+      }, null)
     );
 
     const stmts = path.call(print, "body", 1);

data/src/nodes/class.js

@@ -0,0 +1,74 @@
+const {
+  concat,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  line
+} = require("../prettier");
+
+function printClass(path, opts, print) {
+  const [_constant, superclass, bodystmt] = path.getValue().body;
+  const stmts = bodystmt.body[0];
+
+  const parts = ["class ", path.call(print, "body", 0)];
+  if (superclass) {
+    parts.push(" < ", path.call(print, "body", 1));
+  }
+
+  // If the body is empty and does not contain any comments, we can just
+  // replace the body with a semi-colon.
+  if (
+    stmts.body.length === 1 &&
+    stmts.body[0].type === "void_stmt" &&
+    !stmts.body[0].comments
+  ) {
+    return group(concat([concat(parts), ifBreak(line, "; "), "end"]));
+  }
+
+  return group(
+    concat([
+      concat(parts),
+      indent(concat([hardline, path.call(print, "body", 2)])),
+      concat([hardline, "end"])
+    ])
+  );
+}
+
+function printModule(path, opts, print) {
+  const declaration = group(concat(["module ", path.call(print, "body", 0)]));
+
+  // If the body is empty, we can replace with a ;
+  const stmts = path.getValue().body[1].body[0];
+  if (
+    stmts.body.length === 1 &&
+    stmts.body[0].type === "void_stmt" &&
+    !stmts.body[0].comments
+  ) {
+    return group(concat([declaration, ifBreak(line, "; "), "end"]));
+  }
+
+  return group(
+    concat([
+      declaration,
+      indent(concat([hardline, path.call(print, "body", 1)])),
+      concat([hardline, "end"])
+    ])
+  );
+}
+
+function printSClass(path, opts, print) {
+  return group(
+    concat([
+      concat(["class << ", path.call(print, "body", 0)]),
+      indent(concat([hardline, path.call(print, "body", 1)])),
+      concat([hardline, "end"])
+    ])
+  );
+}
+
+module.exports = {
+  class: printClass,
+  module: printModule,
+  sclass: printSClass
+};

data/src/nodes/commands.js

@@ -1,5 +1,14 @@
-const { align, concat, group, ifBreak, join, line } = require("../prettier");
-const { docLength, makeArgs, makeCall } = require("../utils");
+const {
+  align,
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line,
+  softline
+} = require("../prettier");
+const { docLength, makeCall } = require("../utils");
 
 const hasDef = (node) =>
   node.body[1].type === "args_add_block" &&
@@ -23,32 +32,39 @@ const hasDef = (node) =>
 const skipArgsAlign = (path) =>
   ["to", "not_to"].includes(path.getValue().body[2].body);
 
+// If there is a ternary argument to a command and it's going to get broken
+// into multiple lines, then we're going to have to use parentheses around the
+// command in order to make sure operator precedence doesn't get messed up.
+const hasTernaryArg = (path) =>
+  path.getValue().body[1].body[0].body.some((node) => node.type === "ifop");
+
 module.exports = {
   command: (path, opts, print) => {
     const command = path.call(print, "body", 0);
-    const { args, heredocs } = makeArgs(path, opts, print, 1);
+    const joinedArgs = join(concat([",", line]), path.call(print, "body", 1));
 
-    if (heredocs.length > 1) {
-      return concat([command, " ", join(", ", args)].concat(heredocs));
-    }
+    const hasTernary = hasTernaryArg(path);
+    let breakArgs;
 
-    const joinedArgs = join(concat([",", line]), args);
-    const breakArgs = hasDef(path.getValue())
-      ? joinedArgs
-      : align(command.length + 1, joinedArgs);
+    if (hasTernary) {
+      breakArgs = indent(concat([softline, joinedArgs]));
+    } else if (hasDef(path.getValue())) {
+      breakArgs = joinedArgs;
+    } else {
+      breakArgs = align(command.length + 1, joinedArgs);
+    }
 
-    const commandDoc = group(
+    return group(
       ifBreak(
-        concat([command, " ", breakArgs]),
+        concat([
+          command,
+          hasTernary ? "(" : " ",
+          breakArgs,
+          hasTernary ? concat([softline, ")"]) : ""
+        ]),
         concat([command, " ", joinedArgs])
       )
     );
-
-    if (heredocs.length === 1) {
-      return group(concat([commandDoc].concat(heredocs)));
-    }
-
-    return commandDoc;
   },
   command_call: (path, opts, print) => {
     const parts = [
@@ -62,25 +78,14 @@ module.exports = {
     }
 
     parts.push(" ");
-    const { args, heredocs } = makeArgs(path, opts, print, 3);
-
-    if (heredocs.length > 1) {
-      return concat(parts.concat([join(", ", args)]).concat(heredocs));
-    }
 
-    const joinedArgs = join(concat([",", line]), args);
+    const joinedArgs = join(concat([",", line]), path.call(print, "body", 3));
     const breakArgs = skipArgsAlign(path)
       ? joinedArgs
       : align(docLength(concat(parts)), joinedArgs);
 
-    const commandDoc = group(
+    return group(
       ifBreak(concat(parts.concat(breakArgs)), concat(parts.concat(joinedArgs)))
     );
-
-    if (heredocs.length === 1) {
-      return group(concat([commandDoc].concat(heredocs)));
-    }
-
-    return commandDoc;
   }
 };