prettier 0.22.0 → 1.1.0

data/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.22.0",
+  "version": "1.1.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
+    "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "print": "prettier --plugin=.",
     "test": "jest"
   },
   "repository": {
@@ -25,9 +25,9 @@
     "all-contributors-cli": "^6.14.1",
     "eslint": "^7.8.1",
     "eslint-config-prettier": "^7.0.0",
-    "husky": "^5.0.4",
+    "husky": "^4.3.5",
     "jest": "^26.0.0",
-    "pretty-quick": "^3.0.0"
+    "pretty-quick": "^3.1.0"
   },
   "eslintConfig": {
     "extends": [
@@ -50,6 +50,8 @@
     }
   },
   "jest": {
+    "globalSetup": "./test/js/globalSetup.js",
+    "globalTeardown": "./test/js/globalTeardown.js",
     "setupFilesAfterEnv": [
       "./test/js/setupTests.js"
     ],
@@ -61,6 +63,9 @@
     }
   },
   "prettier": {
-    "trailingComma": "none"
+    "trailingComma": "none",
+    "plugins": [
+      "."
+    ]
   }
 }

data/src/embed.js

@@ -31,7 +31,7 @@ const replaceNewlines = (doc) =>
       : currentDoc
   );
 
-const embed = (path, _print, textToDoc, _opts) => {
+const embed = (path, print, textToDoc, _opts) => {
   const node = path.getValue();
 
   // Currently we only support embedded formatting on heredoc nodes
@@ -47,7 +47,7 @@ const embed = (path, _print, textToDoc, _opts) => {
 
   // Next, find the parser associated with this heredoc (if there is one). For
   // example, if you use <<~CSS, we'd hook it up to the css parser.
-  const parser = parsers[beging.slice(3).toLowerCase()];
+  const parser = parsers[beging.body.slice(3).toLowerCase()];
   if (!parser) {
     return null;
   }
@@ -62,12 +62,16 @@ const embed = (path, _print, textToDoc, _opts) => {
 
   // If we're using a squiggly heredoc, then we can properly handle indentation
   // ourselves.
-  if (beging[2] === "~") {
+  if (beging.body[2] === "~") {
     return concat([
-      beging,
+      path.call(print, "beging"),
       lineSuffix(
         group(
-          concat([indent(markAsRoot(formatted)), literalLineNoBreak, ending])
+          concat([
+            indent(markAsRoot(formatted)),
+            literalLineNoBreak,
+            ending.trim()
+          ])
         )
       )
     ]);
@@ -77,8 +81,8 @@ const embed = (path, _print, textToDoc, _opts) => {
   // content as it is.
   return markAsRoot(
     concat([
-      beging,
-      lineSuffix(group(concat([formatted, literalLineNoBreak, ending])))
+      path.call(print, "beging"),
+      lineSuffix(group(concat([formatted, literalLineNoBreak, ending.trim()])))
     ])
   );
 };

data/src/nodes/args.js

@@ -9,81 +9,56 @@ const {
 } = require("../prettier");
 
 const toProc = require("../toProc");
-const { docLength } = require("../utils");
-
-module.exports = {
-  arg_paren: (path, opts, print) => {
-    const argsNode = path.getValue().body[0];
-    const { addTrailingCommas } = opts;
-
-    if (argsNode === null) {
-      return "";
-    }
-
-    // Here we can skip the entire rest of the method by just checking if it's
-    // an args_forward node, as we're guaranteed that there are no other arg
-    // nodes.
-    if (argsNode.type === "args_forward") {
-      return group(
+const { getTrailingComma } = require("../utils");
+
+function printArgParen(path, opts, print) {
+  const argsNode = path.getValue().body[0];
+
+  if (argsNode === null) {
+    return "";
+  }
+
+  // Here we can skip the entire rest of the method by just checking if it's
+  // an args_forward node, as we're guaranteed that there are no other arg
+  // nodes.
+  if (argsNode.type === "args_forward") {
+    return group(
+      concat([
+        "(",
+        indent(concat([softline, path.call(print, "body", 0)])),
+        softline,
+        ")"
+      ])
+    );
+  }
+
+  const args = path.call(print, "body", 0);
+  const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
+
+  // Now here we return a doc that represents the whole grouped expression,
+  // including the surrouding parentheses.
+  return group(
+    concat([
+      "(",
+      indent(
         concat([
-          "(",
-          indent(concat([softline, path.call(print, "body", 0)])),
           softline,
-          ")"
+          join(concat([",", line]), args),
+          getTrailingComma(opts) && !hasBlock ? ifBreak(",", "") : ""
         ])
-      );
-    }
-
-    const args = path.call(print, "body", 0);
-    const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
-
-    // These are the docs representing the actual arguments, without any
-    // parentheses or surrounding lines yet added.
-    let argsDocs = [
-      join(concat([",", line]), args),
-      addTrailingCommas && !hasBlock ? ifBreak(",", "") : ""
-    ];
-
-    // Here we're going to make a determination on whether or not we should put
-    // a newline before the first argument. In some cases this makes the
-    // appearance a little better. For example, instead of taking this input:
-    //
-    //     foo(arg1, arg2).bar(arg1, arg2).baz(arg1)
-    //
-    // and transforming it into this:
-    //
-    //     foo(arg1, arg2).bar(arg1, arg2).baz(
-    //       arg1
-    //     )
-    //
-    // it instead gets transformed into this:
-    //
-    //     foo(arg1, arg2).bar(arg1, arg2)
-    //       .baz(arg1)
-    //
-    const maxDocLength = 15;
-    const firstArgDoc = args[0];
-
-    // prettier-ignore
-    const shouldWrapLine =
-      (args.reduce((sum, arg) => sum + docLength(arg), 0) > maxDocLength) ||
-      (args.length == 1 && firstArgDoc.type === "group" && docLength(firstArgDoc) > maxDocLength) ||
-      (firstArgDoc.type === "concat" && firstArgDoc.parts.some((part) => part.type === "group"));
-
-    // Here we're going to get all of the docs representing the doc that's
-    // inside the parentheses.
-    if (shouldWrapLine) {
-      argsDocs = [indent(concat([softline].concat(argsDocs))), softline];
-    } else {
-      argsDocs = [indent(concat(argsDocs))];
-    }
-
-    // Now here we return a doc that represents the whole grouped expression,
-    // including the surrouding parentheses.
-    return group(concat(["("].concat(argsDocs).concat(")")));
-  },
-  args: (path, opts, print) => {
-    const args = path.map(print, "body");
+      ),
+      softline,
+      ")"
+    ])
+  );
+}
+
+function printArgs(path, { rubyToProc }, print) {
+  const args = path.map(print, "body");
+
+  // Don't bother trying to do any kind of fancy toProc transform if the
+  // option is disabled.
+  if (rubyToProc) {
     let blockNode = null;
 
     // Look up the chain to see if these arguments are contained within a
@@ -100,21 +75,26 @@ module.exports = {
       return blockNode;
     });
 
-    const proc = blockNode && toProc(path, opts, blockNode);
+    const proc = blockNode && toProc(path, blockNode);
 
-    // If we have a successful to_proc transformation, but we're part of an aref
-    // node, that means it's something to the effect of
+    // If we have a successful to_proc transformation, but we're part of an
+    // aref node, that means it's something to the effect of
     //
     //     foo[:bar].each(&:to_s)
     //
-    // In this case we need to just return regular arguments, otherwise we would
-    // end up putting &:to_s inside the brackets accidentally.
+    // In this case we need to just return regular arguments, otherwise we
+    // would end up putting &:to_s inside the brackets accidentally.
     if (proc && path.getParentNode(1).type !== "aref") {
       args.push(proc);
     }
+  }
 
-    return args;
-  },
+  return args;
+}
+
+module.exports = {
+  arg_paren: printArgParen,
+  args: printArgs,
   args_add_block: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 

data/src/nodes/arrays.js

@@ -1,7 +1,6 @@
 const {
   concat,
   group,
-  hardline,
   ifBreak,
   indent,
   join,
@@ -9,6 +8,8 @@ const {
   softline
 } = 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
 // that looks something like:
@@ -16,31 +17,35 @@ const {
 //     ['a', 'b', 'c']
 //
 function isStringArray(args) {
-  return args.body.every((arg) => {
-    // We want to verify that every node inside of this array is a string
-    // literal. We also want to make sure none of them have comments attached.
-    if (arg.type !== "string_literal" || arg.comments) {
-      return false;
-    }
-
-    // If the string has multiple parts (meaning plain string content but also
-    // interpolated content) then we know it's not a simple string.
-    if (arg.body.length !== 1) {
-      return false;
-    }
-
-    const part = arg.body[0];
-
-    // If the only part of this string is not @tstring_content then it's
-    // interpolated, so again we can return false.
-    if (part.type !== "@tstring_content") {
-      return false;
-    }
-
-    // Finally, verify that the string doesn't contain a space or an escape
-    // character so that we know it can be put into a string literal array.
-    return !part.body.includes(" ") && !part.body.includes("\\");
-  });
+  return (
+    args.body.length > 1 &&
+    args.body.every((arg) => {
+      // We want to verify that every node inside of this array is a string
+      // literal. We also want to make sure none of them have comments attached.
+      if (arg.type !== "string_literal" || arg.comments) {
+        return false;
+      }
+
+      // If the string has multiple parts (meaning plain string content but also
+      // interpolated content) then we know it's not a simple string.
+      if (arg.body.length !== 1) {
+        return false;
+      }
+
+      const part = arg.body[0];
+
+      // If the only part of this string is not @tstring_content then it's
+      // interpolated, so again we can return false.
+      if (part.type !== "@tstring_content") {
+        return false;
+      }
+
+      // Finally, verify that the string doesn't contain a space, an escape
+      // character, or brackets so that we know it can be put into a string
+      // literal array.
+      return !/[\s\\[\]]/.test(part.body);
+    })
+  );
 }
 
 // Checks that every argument within this args node is a symbol_literal node (as
@@ -50,8 +55,9 @@ function isStringArray(args) {
 //     [:a, :b, :c]
 //
 function isSymbolArray(args) {
-  return args.body.every(
-    (arg) => arg.type === "symbol_literal" && !arg.comments
+  return (
+    args.body.length > 1 &&
+    args.body.every((arg) => arg.type === "symbol_literal" && !arg.comments)
   );
 }
 
@@ -86,24 +92,6 @@ function printSpecialArray(start) {
   };
 }
 
-function printEmptyArrayWithComments(path, opts) {
-  const arrayNode = path.getValue();
-
-  const printComment = (commentPath, index) => {
-    arrayNode.comments[index].printed = true;
-    return opts.printer.printComment(commentPath);
-  };
-
-  return concat([
-    "[",
-    indent(
-      concat([hardline, join(hardline, path.map(printComment, "comments"))])
-    ),
-    line,
-    "]"
-  ]);
-}
-
 // An array node is any literal array in Ruby. This includes all of the special
 // array literals as well as regular arrays. If it is a special array literal
 // then it will have one child that represents the special array, otherwise it
@@ -115,12 +103,12 @@ function printArray(path, opts, print) {
   // If there is no inner arguments node, then we're dealing with an empty
   // array, so we can go ahead and return.
   if (args === null) {
-    return array.comments ? printEmptyArrayWithComments(path, opts) : "[]";
+    return printEmptyCollection(path, opts, "[", "]");
   }
 
   // If we have an array that contains only simple string literals with no
   // spaces or interpolation, then we're going to print a %w array.
-  if (isStringArray(args)) {
+  if (opts.rubyArrayLiteral && isStringArray(args)) {
     const printString = (stringPath) => stringPath.call(print, "body", 0);
     const parts = path.map(printString, "body", 0, "body");
 
@@ -129,7 +117,7 @@ function printArray(path, opts, print) {
 
   // If we have an array that contains only simple symbol literals with no
   // interpolation, then we're going to print a %i array.
-  if (isSymbolArray(args)) {
+  if (opts.rubyArrayLiteral && isSymbolArray(args)) {
     const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
     const parts = path.map(printSymbol, "body", 0, "body");
 
@@ -153,7 +141,7 @@ function printArray(path, opts, print) {
         concat([
           softline,
           join(concat([",", line]), path.call(print, "body", 0)),
-          opts.addTrailingCommas ? ifBreak(",", "") : ""
+          getTrailingComma(opts) ? ifBreak(",", "") : ""
         ])
       ),
       softline,

data/src/nodes/assign.js

@@ -1,5 +1,5 @@
 const { concat, group, indent, join, line } = require("../prettier");
-const { concatBody, first, skipAssignIndent } = require("../utils");
+const { first, skipAssignIndent } = require("../utils");
 
 function printAssign(path, opts, print) {
   const [_targetNode, valueNode] = path.getValue().body;
@@ -34,6 +34,6 @@ function printOpAssign(path, opts, print) {
 module.exports = {
   assign: printAssign,
   opassign: printOpAssign,
-  var_field: concatBody,
+  var_field: first,
   var_ref: first
 };

data/src/nodes/calls.js

@@ -6,40 +6,31 @@ const {
   indent,
   softline
 } = require("../prettier");
-const { concatBody, first, makeCall } = require("../utils");
+const { first, makeCall, noIndent } = require("../utils");
 
 const toProc = require("../toProc");
 
-const chained = ["call", "method_add_arg"];
-const noIndent = ["array", "hash", "if", "method_add_block", "xstring_literal"];
+const chained = ["call", "method_add_arg", "method_add_block"];
 
 function printCall(path, opts, print) {
-  const callNode = path.getValue();
-  const [receiverNode, _operatorNode, messageNode] = callNode.body;
+  const node = path.getValue();
+  const [receiverNode, _operatorNode, messageNode] = node.body;
 
   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.
-  const messageDoc =
-    messageNode === "call" ? messageNode : 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]);
-  }
+  // 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 = indent(
-    concat([
-      receiverNode.comments ? hardline : softline,
-      operatorDoc,
-      messageDoc
-    ])
-  );
+  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();
@@ -47,33 +38,56 @@ 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)) {
-    parentNode.chain = (callNode.chain || 0) + 1;
-    parentNode.breakDoc = (callNode.breakDoc || [receiverDoc]).concat(
-      rightSideDoc
-    );
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.callChain = (node.callChain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
   }
 
   // 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) && (callNode.chain || 0) >= 3) {
+  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
     return ifBreak(
-      group(concat(callNode.breakDoc.concat(rightSideDoc))),
+      group(indent(concat(node.breakDoc.concat(rightSideDoc)))),
       concat([receiverDoc, group(rightSideDoc)])
     );
   }
 
-  return group(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 group(concat([receiverDoc, group(indent(rightSideDoc))]));
 }
 
 function printMethodAddArg(path, opts, print) {
-  const methodAddArgNode = path.getValue();
-  const argNode = methodAddArgNode.body[1];
+  const node = path.getValue();
 
+  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;
   }
 
@@ -89,20 +103,30 @@ 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)) {
-    parentNode.chain = (methodAddArgNode.chain || 0) + 1;
-    parentNode.breakDoc = (methodAddArgNode.breakDoc || [methodDoc]).concat(
-      argsDoc
-    );
+    parentNode.chain = (node.chain || 0) + 1;
+    parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
   }
 
   // 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) &&
-    (methodAddArgNode.chain || 0) >= 3
-  ) {
+  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(concat(methodAddArgNode.breakDoc.concat(argsDoc))),
+      group(indent(concat(node.breakDoc.concat(argsDoc)))),
       concat([methodDoc, argsDoc])
     );
   }
@@ -110,15 +134,47 @@ function printMethodAddArg(path, opts, print) {
   return concat([methodDoc, argsDoc]);
 }
 
-module.exports = {
-  call: printCall,
-  fcall: concatBody,
-  method_add_arg: printMethodAddArg,
-  method_add_block: (path, opts, print) => {
-    const [method, block] = path.getValue().body;
-    const proc = toProc(path, opts, block);
+// 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"
+  );
+}
 
-    if (proc && method.type === "call") {
+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),
@@ -132,8 +188,34 @@ module.exports = {
     if (proc) {
       return path.call(print, "body", 0);
     }
+  }
 
-    return concat(path.map(print, "body"));
-  },
+  // 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 || [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
 };