prettier 1.0.1 → 1.2.3

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;
@@ -31,9 +31,17 @@ function printOpAssign(path, opts, print) {
   );
 }
 
+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: first,
-  var_ref: first
+  var_field: printVarField,
+  var_ref: printVarRef
 };

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

@@ -7,8 +7,8 @@ const {
   join,
   removeLines,
   softline
-} = require("../prettier");
-const { empty, hasAncestor } = require("../utils");
+} = require("../../prettier");
+const { hasAncestor } = require("../../utils");
 
 const printBlock = (braces) => (path, opts, print) => {
   const [variables, statements] = path.getValue().body;
@@ -81,5 +81,5 @@ module.exports = {
   },
   brace_block: printBlock(true),
   do_block: printBlock(false),
-  excessed_comma: empty
+  excessed_comma: () => ""
 };

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");
 
@@ -39,16 +39,20 @@ function printCall(path, opts, print) {
   // 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.callChain = (node.callChain || 0) + 1;
     parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
+    parentNode.firstReceiverType = node.firstReceiverType || receiverNode.type;
   }
 
   // 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)])
-    );
+    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
@@ -62,13 +66,31 @@ function printCall(path, opts, print) {
 
 function printMethodAddArg(path, opts, print) {
   const node = path.getValue();
-  const argNode = node.body[1];
 
+  const [methodNode, argNode] = node.body;
   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.
+  // because the parser knows that it cannot be a local variable. You can also
+  // end up here if you are explicitly using an empty set of parentheses.
   if (argsDoc.length === 0) {
+    // If you're using an explicit set of parentheses on something that looks
+    // like a constant, then we need to match that in order to maintain valid
+    // Ruby. For example, you could do something like Foo(), on which we would
+    // need to keep the parentheses to make it look like a method call.
+    if (methodNode.type === "fcall" && methodNode.body[0].type === "@const") {
+      return concat([methodDoc, "()"]);
+    }
+
+    // If you're using an explicit set parentheses with the special call syntax,
+    // then we need to explicitly print out an extra set of parentheses. For
+    // example, if you call something like Foo.new.() (implicitly calling the
+    // #call method on a new instance of the Foo class), then we have to print
+    // out those parentheses, otherwise we'll end up with Foo.new.
+    if (methodNode.type === "call" && methodNode.body[2] === "call") {
+      return concat([methodDoc, "()"]);
+    }
+
     return methodDoc;
   }
 
@@ -86,11 +108,27 @@ function printMethodAddArg(path, opts, print) {
   if (chained.includes(parentNode.type)) {
     parentNode.chain = (node.chain || 0) + 1;
     parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
+    parentNode.firstReceiverType = node.firstReceiverType;
   }
 
   // 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) {
+    // This is pretty specialized behavior. Basically if we're at the top of a
+    // chain but we've only had method calls without arguments and now we have
+    // arguments, then we're effectively trying to call a method with arguments
+    // that is nested under a bunch of stuff. So we group together to first part
+    // to make it so just the arguments break. This looks like, for example:
+    //
+    //     config.action_dispatch.rescue_responses.merge!(
+    //       'ActiveRecord::ConnectionTimeoutError' => :service_unavailable,
+    //       'ActiveRecord::QueryCanceled' => :service_unavailable
+    //     )
+    //
+    if (node.callChain === node.chain) {
+      return concat([group(indent(concat(node.breakDoc))), group(argsDoc)]);
+    }
+
     return ifBreak(
       group(indent(concat(node.breakDoc.concat(argsDoc)))),
       concat([methodDoc, argsDoc])
@@ -118,7 +156,7 @@ function isSorbetTypeAnnotation(node) {
     callNode.body[0].body[0].body === "sig" &&
     callNode.body[1].type === "args" &&
     callNode.body[1].body.length === 0 &&
-    blockNode.type === "brace_block"
+    blockNode
   );
 }
 
@@ -164,6 +202,7 @@ function printMethodAddBlock(path, opts, print) {
   if (chained.includes(parentNode.type)) {
     parentNode.chain = (node.chain || 0) + 1;
     parentNode.breakDoc = (node.breakDoc || [callDoc]).concat(blockDoc);
+    parentNode.firstReceiverType = node.firstReceiverType;
   }
 
   // If we're at the top of a chain, then we're going to print out a nice
@@ -178,10 +217,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/ruby/nodes/case.js

@@ -0,0 +1,65 @@
+const {
+  align,
+  concat,
+  fill,
+  group,
+  hardline,
+  indent,
+  line
+} = require("../../prettier");
+
+function printCase(path, opts, print) {
+  const statement = ["case"];
+
+  // You don't need to explicitly have something to test against in a case
+  // statement (without it it effectively becomes an if/elsif chain).
+  if (path.getValue().body[0]) {
+    statement.push(" ", path.call(print, "body", 0));
+  }
+
+  return concat(
+    statement.concat([hardline, path.call(print, "body", 1), hardline, "end"])
+  );
+}
+
+function printWhen(path, opts, print) {
+  const [_preds, _stmts, addition] = path.getValue().body;
+
+  // 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) => {
+      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);
+  const parts = [concat(["when ", align("when ".length, preds)])];
+
+  // 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)) {
+    parts.push(indent(concat([hardline, stmts])));
+  }
+
+  // This is the next clause on the case statement, either another `when` or
+  // an `else` clause.
+  if (addition) {
+    parts.push(hardline, path.call(print, "body", 2));
+  }
+
+  return group(concat(parts));
+}
+
+module.exports = {
+  case: printCase,
+  when: printWhen
+};

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,126 @@
+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])) {
+    parts.push("(");
+    breakDoc = parts.concat(indent(concat([softline, argDocs])), softline, ")");
+  } 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
+};

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

@@ -7,10 +7,10 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
+} = require("../../prettier");
 
-const { containsAssignment, isEmptyStmts } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([

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

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, softline } = require("../prettier");
-const { makeCall } = require("../utils");
+const { concat, group, indent, join, softline } = require("../../prettier");
+const { makeCall } = require("../../utils");
 
 function printConstPath(path, opts, print) {
   return join("::", path.map(print, "body"));

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

@@ -1,5 +1,5 @@
-const { concat, join } = require("../prettier");
-const { literal } = require("../utils");
+const { concat, join } = require("../../prettier");
+const { literal } = require("../../utils");
 
 const nodeDive = (node, steps) => {
   let current = node;

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

@@ -1,11 +1,16 @@
-const { concat, group, ifBreak, indent, join, line } = require("../prettier");
-
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line
+} = require("../../prettier");
 const {
   getTrailingComma,
-  prefix,
   printEmptyCollection,
   skipAssignIndent
-} = require("../utils");
+} = require("../../utils");
 
 // When attempting to convert a hash rocket into a hash label, you need to take
 // care because only certain patterns are allowed. Ruby source says that they
@@ -49,8 +54,20 @@ function printHashKeyLabel(path, print) {
       return print(path);
     case "symbol_literal":
       return concat([path.call(print, "body", 0), ":"]);
-    case "dyna_symbol":
-      return concat(print(path).parts.slice(1).concat(":"));
+    case "dyna_symbol": {
+      const { parts } = print(path);
+
+      // We're going to slice off the starting colon character so that we can
+      // move it to the end. If there are comments, then we're going to go
+      // further into the printed doc nodes.
+      if (parts[0] === ":") {
+        parts.splice(0, 1);
+      } else {
+        parts[1].parts.splice(0, 1);
+      }
+
+      return concat(parts.concat(":"));
+    }
   }
 }
 
@@ -66,20 +83,25 @@ function printHashKeyRocket(path, print) {
 }
 
 function printAssocNew(path, opts, print) {
+  const [keyNode, valueNode] = path.getValue().body;
   const { keyPrinter } = path.getParentNode();
 
   const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
   const valueDoc = path.call(print, "body", 1);
 
-  if (skipAssignIndent(path.getValue().body[1])) {
-    parts.push(" ", valueDoc);
-  } else {
+  if (!skipAssignIndent(valueNode) || keyNode.comments) {
     parts.push(indent(concat([line, valueDoc])));
+  } else {
+    parts.push(" ", valueDoc);
   }
 
   return group(concat(parts));
 }
 
+function printAssocSplat(path, opts, print) {
+  return concat(["**", path.call(print, "body", 0)]);
+}
+
 function printHashContents(path, opts, print) {
   const node = path.getValue();
 
@@ -121,7 +143,7 @@ function printHash(path, opts, print) {
 
 module.exports = {
   assoc_new: printAssocNew,
-  assoc_splat: prefix("**"),
+  assoc_splat: printAssocSplat,
   assoclist_from_args: printHashContents,
   bare_assoc_hash: printHashContents,
   hash: printHash