prettier 0.20.0 → 1.0.0.pre.rc2

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.20.0",
+  "version": "1.0.0-rc2",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -23,9 +23,9 @@
   },
   "devDependencies": {
     "all-contributors-cli": "^6.14.1",
-    "eslint": "^7.1.0",
-    "eslint-config-prettier": "^6.10.1",
-    "husky": "^4.2.5",
+    "eslint": "^7.8.1",
+    "eslint-config-prettier": "^7.0.0",
+    "husky": "^5.0.4",
     "jest": "^26.0.0",
     "pretty-quick": "^3.0.0"
   },

data/src/embed.js

@@ -1,12 +1,15 @@
 const {
   concat,
+  group,
   indent,
-  literalline,
+  lineSuffix,
   mapDoc,
   markAsRoot,
   stripTrailingHardline
 } = require("./prettier");
 
+const { literalLineNoBreak } = require("./utils");
+
 const parsers = {
   css: "css",
   javascript: "babel",
@@ -23,12 +26,12 @@ const replaceNewlines = (doc) =>
       ? concat(
           currentDoc
             .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literalline))
+            .map((v, i) => (i % 2 === 0 ? v : literalLineNoBreak))
         )
       : 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
@@ -44,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;
   }
@@ -53,19 +56,35 @@ const embed = (path, _print, textToDoc, _opts) => {
   // into the embedded parser. Get back the doc node.
   const content = body.map((part) => part.body).join("");
   const formatted = concat([
-    literalline,
+    literalLineNoBreak,
     replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
   ]);
 
   // If we're using a squiggly heredoc, then we can properly handle indentation
   // ourselves.
-  if (beging[2] === "~") {
-    return concat([beging, indent(markAsRoot(formatted)), literalline, ending]);
+  if (beging.body[2] === "~") {
+    return concat([
+      path.call(print, "beging"),
+      lineSuffix(
+        group(
+          concat([
+            indent(markAsRoot(formatted)),
+            literalLineNoBreak,
+            ending.trim()
+          ])
+        )
+      )
+    ]);
   }
 
   // Otherwise, we need to just assume it's formatted correctly and return the
   // content as it is.
-  return markAsRoot(concat([beging, formatted, literalline, ending]));
+  return markAsRoot(
+    concat([
+      path.call(print, "beging"),
+      lineSuffix(group(concat([formatted, literalLineNoBreak, ending.trim()])))
+    ])
+  );
 };
 
 module.exports = embed;

data/src/nodes.js

@@ -1,17 +1,20 @@
 module.exports = Object.assign(
   {},
   require("./nodes/alias"),
+  require("./nodes/aref"),
   require("./nodes/args"),
   require("./nodes/arrays"),
   require("./nodes/assign"),
   require("./nodes/blocks"),
   require("./nodes/calls"),
   require("./nodes/case"),
+  require("./nodes/class"),
   require("./nodes/commands"),
   require("./nodes/conditionals"),
   require("./nodes/constants"),
   require("./nodes/flow"),
   require("./nodes/hashes"),
+  require("./nodes/heredocs"),
   require("./nodes/hooks"),
   require("./nodes/ints"),
   require("./nodes/lambdas"),
@@ -24,7 +27,8 @@ module.exports = Object.assign(
   require("./nodes/regexp"),
   require("./nodes/rescue"),
   require("./nodes/return"),
-  require("./nodes/scopes"),
   require("./nodes/statements"),
-  require("./nodes/strings")
+  require("./nodes/strings"),
+  require("./nodes/super"),
+  require("./nodes/undef")
 );

data/src/nodes/alias.js

@@ -1,32 +1,73 @@
-const { concat, join } = require("../prettier");
+const {
+  addTrailingComment,
+  align,
+  concat,
+  group,
+  hardline,
+  line
+} = require("../prettier");
 
-const usingSymbols = (path) => {
-  const [left, right] = path.getValue().body.map((node) => node.body[0].type);
-  return left === "symbol" && right === "symbol";
-};
-
-const identFromSymbol = (path, print, index) =>
-  path.call(print, "body", index, "body", 0, "body", 0);
+// 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
+// convert those into bare words by just pulling out the ident node.
+function printAliasArgument(path, print, argIndex) {
+  const node = path.getValue().body[argIndex];
 
-const aliasError = (_path, _opts, _print) => {
-  throw new Error("can't make alias for the number variables");
-};
+  if (node.type === "symbol_literal") {
+    // If we're going to descend into the symbol literal to grab out the ident
+    // node, then we need to make sure we copy over any comments as well,
+    // otherwise we could accidentally skip printing them.
+    if (node.comments) {
+      node.comments.forEach((comment) => {
+        addTrailingComment(node.body[0], comment);
+      });
+    }
 
-const aliasVars = (path, opts, print) => {
-  if (usingSymbols(path)) {
-    return join(" ", [
-      identFromSymbol(path, print, 0),
-      identFromSymbol(path, print, 1)
-    ]);
+    return path.call(print, "body", argIndex, "body", 0);
   }
-  return join(" ", path.map(print, "body"));
-};
 
-const alias = (path, opts, print) =>
-  concat(["alias ", aliasVars(path, opts, print)]);
+  return path.call(print, "body", argIndex);
+}
+
+// The `alias` keyword is used to make a method respond to another name as well
+// as the current one. For example, to get the method `foo` to also respond to
+// `bar`, you would:
+//
+//     alias bar foo
+//
+// Now, in the current context you can call `bar` and it will execute the `foo`
+// method.
+//
+// When you're aliasing two methods, you can either provide bare words (like the
+// example above) or you can provide symbols (note that this includes dynamic
+// symbols like :"foo-#{bar}-baz"). In general, to be consistent with the ruby
+// style guide, we prefer bare words:
+//
+//     https://github.com/rubocop-hq/ruby-style-guide#alias-method-lexically
+//
+// The `alias` node contains two children. The left and right align with the
+// arguments passed to the keyword. So, for the above example the left would be
+// the symbol literal `bar` and the right could be the symbol literal `foo`.
+function printAlias(path, opts, print) {
+  const keyword = "alias ";
+
+  const rightSide = concat([
+    // If the left child has any comments, then we need to explicitly break this
+    // into two lines
+    path.getValue().body[0].comments ? hardline : line,
+    printAliasArgument(path, print, 1)
+  ]);
+
+  return group(
+    concat([
+      keyword,
+      printAliasArgument(path, print, 0),
+      group(align(keyword.length, rightSide))
+    ])
+  );
+}
 
 module.exports = {
-  alias,
-  alias_error: aliasError,
-  var_alias: alias
+  alias: printAlias,
+  var_alias: printAlias
 };

data/src/nodes/aref.js

@@ -0,0 +1,55 @@
+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
+// `#[]`.
+//
+// The nodes usually contains two children, details below in the
+// `printArefField` function. In some cases, you don't necessarily have the
+// second child node, because you can call procs with a pretty esoteric syntax.
+// In the following example, you wouldn't have a second child, and `"foo"` would
+// be the first child.
+//
+//     foo[]
+//
+function printAref(path, opts, print) {
+  const indexNode = path.getValue().body[1];
+
+  if (!indexNode) {
+    return concat([path.call(print, "body", 0), "[]"]);
+  }
+
+  return printArefField(path, opts, print);
+}
+
+// `aref_field` nodes are for assigning values into collections at specific
+// indices. Put another way, it's any time you're calling the method `#[]=`.
+// The `aref_field` node itself is just the left side of the assignment, and
+// they're always wrapped in `assign` nodes.
+//
+// The nodes always contain two children, the name of the array (usually a
+// `vcall` node and the index (usually an `args_add_block` node). The
+// `args_add_block` is one of a couple nodes that has special handling where its
+// printed form is actually an array to make joining easier.
+//
+// So in the following example, `"foo"` is the array and `["bar"]` is the index.
+//
+//     foo[bar] = baz
+//
+function printArefField(path, opts, print) {
+  const [printedArray, printedIndex] = path.map(print, "body");
+
+  return group(
+    concat([
+      printedArray,
+      "[",
+      indent(concat([softline, join(concat([",", line]), printedIndex)])),
+      concat([softline, "]"])
+    ])
+  );
+}
+
+module.exports = {
+  aref: printAref,
+  aref_field: printArefField
+};

data/src/nodes/args.js

@@ -9,53 +9,56 @@ const {
 } = require("../prettier");
 
 const toProc = require("../toProc");
-const { makeArgs } = require("../utils");
+const { getTrailingComma } = require("../utils");
 
-module.exports = {
-  arg_paren: (path, opts, print) => {
-    if (path.getValue().body[0] === 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 (path.getValue().body[0].type === "args_forward") {
-      return "(...)";
-    }
+function printArgParen(path, opts, print) {
+  const argsNode = path.getValue().body[0];
 
-    const { addTrailingCommas } = opts;
-    const { args, heredocs } = makeArgs(path, opts, print, 0);
-
-    const argsNode = path.getValue().body[0];
-    const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
-
-    if (heredocs.length > 1) {
-      return concat(["(", join(", ", args), ")"].concat(heredocs));
-    }
+  if (argsNode === null) {
+    return "";
+  }
 
-    const parenDoc = group(
+  // 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,
-            join(concat([",", line]), args),
-            addTrailingCommas && !hasBlock ? ifBreak(",", "") : ""
-          ])
-        ),
-        concat([softline, ")"])
+        indent(concat([softline, path.call(print, "body", 0)])),
+        softline,
+        ")"
       ])
     );
-
-    if (heredocs.length === 1) {
-      return group(concat([parenDoc].concat(heredocs)));
-    }
-
-    return parenDoc;
-  },
-  args: (path, opts, print) => {
-    const args = path.map(print, "body");
+  }
+
+  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([
+          softline,
+          join(concat([",", line]), args),
+          getTrailingComma(opts) && !hasBlock ? ifBreak(",", "") : ""
+        ])
+      ),
+      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
@@ -72,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,55 +1,79 @@
 const {
   concat,
   group,
+  hardline,
   ifBreak,
   indent,
   join,
   line,
-  literalline,
   softline
 } = require("../prettier");
 
-const preserveArraySubstrings = [" ", "\\"];
-
-const isStringArray = (args) =>
-  args.body.every(
-    (arg) =>
-      arg.type === "string_literal" &&
-      arg.body[0].body.length === 1 &&
-      arg.body[0].body[0].type === "@tstring_content" &&
-      !preserveArraySubstrings.some((str) =>
-        arg.body[0].body[0].body.includes(str)
-      )
-  );
+const { getTrailingComma } = 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:
+//
+//     ['a', 'b', 'c']
+//
+function isStringArray(args) {
+  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;
+      }
 
-const isSymbolArray = (args) =>
-  args.body.every((arg) => arg.type === "symbol_literal");
+      // 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 makeArray = (start) => (path, opts, print) =>
-  [start].concat(path.map(print, "body"));
+      const part = arg.body[0];
 
-const getSpecialArrayParts = (path, print, args) =>
-  args.body.map((_arg, index) =>
-    path.call(print, "body", 0, "body", index, "body", 0, "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;
+      }
 
-const printAref = (path, opts, print) =>
-  group(
-    concat([
-      path.call(print, "body", 0),
-      "[",
-      indent(
-        concat([
-          softline,
-          join(concat([",", line]), path.call(print, "body", 1))
-        ])
-      ),
-      concat([softline, "]"])
-    ])
+      // 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);
+    })
   );
-
-const printSpecialArray = (parts) =>
-  group(
+}
+
+// Checks that every argument within this args node is a symbol_literal node (as
+// opposed to a dyna_symbol) so it has no interpolation. This means we're
+// dealing with an array that looks something like:
+//
+//     [:a, :b, :c]
+//
+function isSymbolArray(args) {
+  return (
+    args.body.length > 1 &&
+    args.body.every((arg) => arg.type === "symbol_literal" && !arg.comments)
+  );
+}
+
+// Prints out a word that is a part of a special array literal that accepts
+// interpolation. The body is an array of either plain strings or interpolated
+// expressions.
+function printSpecialArrayWord(path, opts, print) {
+  return concat(path.map(print, "body"));
+}
+
+// Prints out a special array literal. Accepts the parts of the array literal as
+// an argument, where the first element of the parts array is a string that
+// contains the special start.
+function printSpecialArrayParts(parts) {
+  return group(
     concat([
       parts[0],
       "[",
@@ -57,110 +81,99 @@ const printSpecialArray = (parts) =>
       concat([softline, "]"])
     ])
   );
+}
+
+// Generates a print function with an embedded special start character for the
+// specific type of array literal that we're dealing with. The print function
+// returns an array as it expects to eventually be handed off to
+// printSpecialArrayParts.
+function printSpecialArray(start) {
+  return function printSpecialArrayWithStart(path, opts, print) {
+    return [start].concat(path.map(print, "body"));
+  };
+}
+
+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
+// will have one child that contains all of the elements of the array.
+function printArray(path, opts, print) {
+  const array = path.getValue();
+  const args = array.body[0];
+
+  // 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) : "[]";
+  }
 
-// Extract out the actual elements, taking into account nesting with
-// `args_add_star` nodes. The only nodes that get passed into this function are
-// `args` or `args_add_star`.
-const getElements = (node, elementPath) => {
-  if (node.type === "args") {
-    return node.body.map((element, index) => ({
-      element,
-      elementPath: elementPath.concat(["body", index])
-    }));
+  // 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 (opts.rubyArrayLiteral && isStringArray(args)) {
+    const printString = (stringPath) => stringPath.call(print, "body", 0);
+    const parts = path.map(printString, "body", 0, "body");
+
+    return printSpecialArrayParts(["%w"].concat(parts));
+  }
+
+  // If we have an array that contains only simple symbol literals with no
+  // interpolation, then we're going to print a %i array.
+  if (opts.rubyArrayLiteral && isSymbolArray(args)) {
+    const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
+    const parts = path.map(printSymbol, "body", 0, "body");
+
+    return printSpecialArrayParts(["%i"].concat(parts));
   }
 
-  return getElements(node.body[0], elementPath.concat(["body", 0])).concat(
-    node.body.slice(1).map((element, index) => ({
-      element,
-      elementPath: elementPath.concat(["body", index + 1])
-    }))
+  // If we don't have a regular args node at this point then we have a special
+  // array literal. In that case we're going to print out the body (which will
+  // return to us an array with the first one being the start of the array) and
+  // send that over to the printSpecialArrayParts function.
+  if (!["args", "args_add_star"].includes(args.type)) {
+    return printSpecialArrayParts(path.call(print, "body", 0));
+  }
+
+  // Here we have a normal array of any type of object with no special literal
+  // types or anything.
+  return group(
+    concat([
+      "[",
+      indent(
+        concat([
+          softline,
+          join(concat([",", line]), path.call(print, "body", 0)),
+          getTrailingComma(opts) ? ifBreak(",", "") : ""
+        ])
+      ),
+      softline,
+      "]"
+    ])
   );
-};
+}
 
 module.exports = {
-  aref: (path, opts, print) => {
-    if (!path.getValue().body[1]) {
-      return concat([path.call(print, "body", 0), "[]"]);
-    }
-
-    return printAref(path, opts, print);
-  },
-  aref_field: printAref,
-  array: (path, { addTrailingCommas }, print) => {
-    const args = path.getValue().body[0];
-
-    if (args === null) {
-      return "[]";
-    }
-
-    if (isStringArray(args)) {
-      return printSpecialArray(
-        ["%w"].concat(getSpecialArrayParts(path, print, args))
-      );
-    }
-
-    if (isSymbolArray(args)) {
-      return printSpecialArray(
-        ["%i"].concat(getSpecialArrayParts(path, print, args))
-      );
-    }
-
-    if (!["args", "args_add_star"].includes(args.type)) {
-      return printSpecialArray(path.call(print, "body", 0));
-    }
-
-    const normalDocs = [];
-
-    const elementDocs = path.call(print, "body", 0);
-    const elements = getElements(path.getValue().body[0], ["body", 0]);
-
-    // We need to manually loop through the elements in the array in order to
-    // take care of heredocs printing (their commas go after the opening, as
-    // opposed to at the end).
-    elements.forEach(({ element, elementPath }, index) => {
-      const isInner = index !== elements.length - 1;
-
-      const isStraightHeredoc = element.type === "heredoc";
-      const isSquigglyHeredoc =
-        element.type === "string_literal" && element.body[0].type === "heredoc";
-
-      if (isStraightHeredoc || isSquigglyHeredoc) {
-        const heredocNode = isStraightHeredoc ? element : element.body[0];
-        const heredocPath = [print].concat(elementPath);
-
-        if (isSquigglyHeredoc) {
-          heredocPath.push("body", 0);
-        }
-
-        normalDocs.push(
-          heredocNode.beging,
-          isInner || addTrailingCommas ? "," : "",
-          literalline,
-          concat(path.map.apply(path, heredocPath.concat("body"))),
-          heredocNode.ending,
-          isInner ? line : ""
-        );
-      } else {
-        normalDocs.push(elementDocs[index]);
-
-        if (isInner) {
-          normalDocs.push(concat([",", line]));
-        } else if (addTrailingCommas) {
-          normalDocs.push(ifBreak(",", ""));
-        }
-      }
-    });
-
-    return group(
-      concat([
-        "[",
-        indent(concat([softline].concat(normalDocs))),
-        concat([softline, "]"])
-      ])
-    );
-  },
-  qsymbols: makeArray("%i"),
-  qwords: makeArray("%w"),
-  symbols: makeArray("%I"),
-  words: makeArray("%W")
+  array: printArray,
+  qsymbols: printSpecialArray("%i"),
+  qwords: printSpecialArray("%w"),
+  symbols: printSpecialArray("%I"),
+  word: printSpecialArrayWord,
+  words: printSpecialArray("%W")
 };