prettier 1.2.2 → 1.4.0

data/src/{embed.js → ruby/embed.js}

@@ -6,9 +6,9 @@ const {
   mapDoc,
   markAsRoot,
   stripTrailingHardline
-} = require("./prettier");
+} = require("../prettier");
 
-const { literalLineNoBreak } = require("./utils");
+const { literalLineNoBreak } = require("../utils");
 
 const parsers = {
   css: "css",
@@ -20,6 +20,10 @@ const parsers = {
   scss: "scss"
 };
 
+// This function is in here because it handles embedded parser values. I don't
+// have a test that exercises it because I'm not sure for which parser it is
+// necessary, but since it's in prettier core I'm keeping it here.
+/* istanbul ignore next */
 const replaceNewlines = (doc) =>
   mapDoc(doc, (currentDoc) =>
     typeof currentDoc === "string" && currentDoc.includes("\n")

data/src/{nodes → ruby/nodes}/alias.js

@@ -5,7 +5,7 @@ const {
   group,
   hardline,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 // In general, return the printed doc of the argument at the provided index.
 // Special handling is given for symbol literals that are not bare words, as we

data/src/{nodes → ruby/nodes}/aref.js

@@ -1,4 +1,11 @@
-const { concat, group, indent, join, line, softline } = require("../prettier");
+const {
+  concat,
+  group,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
 
 // `aref` nodes are when you're pulling a value out of a collection at a
 // specific index. Put another way, it's any time you're calling the method

data/src/{nodes → ruby/nodes}/args.js

@@ -6,10 +6,10 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
+} = require("../../prettier");
+const { getTrailingComma } = require("../../utils");
 
 const toProc = require("../toProc");
-const { getTrailingComma } = require("../utils");
 
 function printArgParen(path, opts, print) {
   const argsNode = path.getValue().body[0];

data/src/{nodes → ruby/nodes}/arrays.js

@@ -6,9 +6,8 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
-
-const { getTrailingComma, printEmptyCollection } = require("../utils");
+} = require("../../prettier");
+const { getTrailingComma, printEmptyCollection } = require("../../utils");
 
 // Checks that every argument within this args node is a string_literal node
 // that has no spaces or interpolations. This means we're dealing with an array

data/src/{nodes → ruby/nodes}/assign.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, line } = require("../prettier");
-const { first, skipAssignIndent } = require("../utils");
+const { concat, group, indent, join, line } = require("../../prettier");
+const { skipAssignIndent } = require("../../utils");
 
 function printAssign(path, opts, print) {
   const [_targetNode, valueNode] = path.getValue().body;
@@ -35,9 +35,13 @@ function printVarField(path, opts, print) {
   return path.getValue().body ? path.call(print, "body", 0) : "";
 }
 
+function printVarRef(path, opts, print) {
+  return path.call(print, "body", 0);
+}
+
 module.exports = {
   assign: printAssign,
   opassign: printOpAssign,
   var_field: printVarField,
-  var_ref: first
+  var_ref: printVarRef
 };

data/src/ruby/nodes/blocks.js

@@ -0,0 +1,90 @@
+const {
+  breakParent,
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  removeLines,
+  softline
+} = require("../../prettier");
+const { hasAncestor } = require("../../utils");
+
+function printBlockVar(path, opts, print) {
+  const parts = ["|", removeLines(path.call(print, "body", 0))];
+
+  // The second part of this node is a list of optional block-local variables
+  if (path.getValue().body[1]) {
+    parts.push("; ", join(", ", path.map(print, "body", 1)));
+  }
+
+  parts.push("| ");
+  return concat(parts);
+}
+
+function printBlock(braces) {
+  return function printBlockWithBraces(path, opts, print) {
+    const [variables, statements] = path.getValue().body;
+    const stmts =
+      statements.type === "stmts" ? statements.body : statements.body[0].body;
+
+    let doBlockBody = "";
+    if (
+      stmts.length !== 1 ||
+      stmts[0].type !== "void_stmt" ||
+      stmts[0].comments
+    ) {
+      doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
+    }
+
+    // If this block is nested underneath a command or command_call node, then
+    // we can't use `do...end` because that will get associated with the parent
+    // node as opposed to the current node (because of the difference in
+    // operator precedence). Instead, we still use a multi-line format but
+    // switch to using braces instead.
+    const useBraces = braces && hasAncestor(path, ["command", "command_call"]);
+
+    const doBlock = concat([
+      useBraces ? " {" : " do",
+      variables ? concat([" ", path.call(print, "body", 0)]) : "",
+      doBlockBody,
+      concat([softline, useBraces ? "}" : "end"])
+    ]);
+
+    // We can hit this next pattern if within the block the only statement is a
+    // comment.
+    if (
+      stmts.length === 1 &&
+      stmts[0].type === "void_stmt" &&
+      stmts[0].comments
+    ) {
+      return concat([breakParent, doBlock]);
+    }
+
+    const blockReceiver = path.getParentNode().body[0];
+
+    // If the parent node is a command node, then there are no parentheses
+    // around the arguments to that command, so we need to break the block
+    if (["command", "command_call"].includes(blockReceiver.type)) {
+      return concat([breakParent, doBlock]);
+    }
+
+    const hasBody = stmts.some(({ type }) => type !== "void_stmt");
+    const braceBlock = concat([
+      " {",
+      hasBody || variables ? " " : "",
+      variables ? path.call(print, "body", 0) : "",
+      path.call(print, "body", 1),
+      hasBody ? " " : "",
+      "}"
+    ]);
+
+    return group(ifBreak(doBlock, braceBlock));
+  };
+}
+
+module.exports = {
+  block_var: printBlockVar,
+  brace_block: printBlock(true),
+  do_block: printBlock(false)
+};

data/src/{nodes → ruby/nodes}/calls.js

@@ -5,8 +5,8 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
-const { first, makeCall, noIndent } = require("../utils");
+} = require("../../prettier");
+const { makeCall, noIndent } = require("../../utils");
 
 const toProc = require("../toProc");
 
@@ -24,6 +24,12 @@ function printCall(path, opts, print) {
   // call syntax so if `call` is implicit, we don't print it out.
   const messageDoc = messageNode === "call" ? "" : path.call(print, "body", 2);
 
+  // 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]);
+  }
+
   // The right side of the call node, as in everything including the operator
   // and beyond.
   const rightSideDoc = concat([
@@ -37,7 +43,7 @@ function printCall(path, opts, print) {
 
   // 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)) {
+  if (chained.includes(parentNode.type) && !node.comments) {
     parentNode.chain = (node.chain || 0) + 1;
     parentNode.callChain = (node.callChain || 0) + 1;
     parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
@@ -47,18 +53,10 @@ function printCall(path, opts, print) {
   // 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) {
-    let breakDoc = concat(node.breakDoc.concat(rightSideDoc));
-    if (!noIndent.includes(node.firstReceiverType)) {
-      breakDoc = indent(breakDoc);
-    }
-
-    return ifBreak(group(breakDoc), concat([receiverDoc, group(rightSideDoc)]));
-  }
-
-  // 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 ifBreak(
+      group(indent(concat(node.breakDoc.concat(rightSideDoc)))),
+      concat([receiverDoc, group(rightSideDoc)])
+    );
   }
 
   return group(concat([receiverDoc, group(indent(rightSideDoc))]));
@@ -105,7 +103,7 @@ function printMethodAddArg(path, opts, print) {
 
   // 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)) {
+  if (chained.includes(parentNode.type) && !node.comments) {
     parentNode.chain = (node.chain || 0) + 1;
     parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
     parentNode.firstReceiverType = node.firstReceiverType;
@@ -138,41 +136,12 @@ function printMethodAddArg(path, opts, print) {
   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
-  );
-}
-
 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) {
@@ -217,10 +186,14 @@ function printMethodAddBlock(path, opts, print) {
   return concat([callDoc, blockDoc]);
 }
 
+function printCallContainer(path, opts, print) {
+  return path.call(print, "body", 0);
+}
+
 module.exports = {
   call: printCall,
-  fcall: first,
+  fcall: printCallContainer,
   method_add_arg: printMethodAddArg,
   method_add_block: printMethodAddBlock,
-  vcall: first
+  vcall: printCallContainer
 };

data/src/{nodes → ruby/nodes}/case.js

@@ -6,7 +6,7 @@ const {
   hardline,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printCase(path, opts, print) {
   const statement = ["case"];

data/src/{nodes → ruby/nodes}/class.js

@@ -5,7 +5,7 @@ const {
   ifBreak,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printClass(path, opts, print) {
   const [_constant, superclass, bodystmt] = path.getValue().body;

data/src/ruby/nodes/commands.js

@@ -0,0 +1,131 @@
+const {
+  align,
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
+const { makeCall } = require("../../utils");
+
+function docLength(doc) {
+  if (doc.length) {
+    return doc.length;
+  }
+
+  if (doc.parts) {
+    return doc.parts.reduce((sum, child) => sum + docLength(child), 0);
+  }
+
+  if (doc.contents) {
+    return docLength(doc.contents);
+  }
+
+  return 0;
+}
+
+function hasDef(node) {
+  return (
+    node.body[1].type === "args_add_block" &&
+    node.body[1].body[0].type === "args" &&
+    node.body[1].body[0].body[0] &&
+    ["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.
+function skipArgsAlign(path) {
+  return ["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.
+function hasTernaryArg(node) {
+  return node.body[0].body.some((child) => child.type === "ifop");
+}
+
+function printCommand(path, opts, print) {
+  const node = path.getValue();
+
+  const command = path.call(print, "body", 0);
+  const joinedArgs = join(concat([",", line]), path.call(print, "body", 1));
+
+  const hasTernary = hasTernaryArg(node.body[1]);
+  let breakArgs;
+
+  if (hasTernary) {
+    breakArgs = indent(concat([softline, joinedArgs]));
+  } else if (hasDef(path.getValue())) {
+    breakArgs = joinedArgs;
+  } else {
+    breakArgs = align(command.length + 1, joinedArgs);
+  }
+
+  return group(
+    ifBreak(
+      concat([
+        command,
+        hasTernary ? "(" : " ",
+        breakArgs,
+        hasTernary ? concat([softline, ")"]) : ""
+      ]),
+      concat([command, " ", joinedArgs])
+    )
+  );
+}
+
+function printCommandCall(path, opts, print) {
+  const node = path.getValue();
+  const parts = [
+    path.call(print, "body", 0),
+    makeCall(path, opts, print),
+    path.call(print, "body", 2)
+  ];
+
+  if (!node.body[3]) {
+    return concat(parts);
+  }
+
+  const argDocs = join(concat([",", line]), path.call(print, "body", 3));
+  let breakDoc;
+
+  if (hasTernaryArg(node.body[3])) {
+    breakDoc = parts.concat(
+      "(",
+      indent(concat([softline, argDocs])),
+      softline,
+      ")"
+    );
+    parts.push(" ");
+  } else if (skipArgsAlign(path)) {
+    parts.push(" ");
+    breakDoc = parts.concat(argDocs);
+  } else {
+    parts.push(" ");
+    breakDoc = parts.concat(align(docLength(concat(parts)), argDocs));
+  }
+
+  const joinedDoc = parts.concat(argDocs);
+
+  return group(ifBreak(concat(breakDoc), concat(joinedDoc)));
+}
+
+module.exports = {
+  command: printCommand,
+  command_call: printCommandCall
+};