prettier 0.21.0 → 1.0.1

data/src/nodes/aref.js

@@ -1,17 +1,17 @@
 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[]
- */
+// `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];
 
@@ -22,20 +22,20 @@ function printAref(path, opts, print) {
   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
- */
+// `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");
 

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

@@ -5,36 +5,74 @@ const {
   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, 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:
+//
+//     ['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 printSpecialArray = (parts) =>
-  group(
+      // 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
+// 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],
       "[",
@@ -42,93 +80,81 @@ 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"));
+  };
+}
+
+// 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 printEmptyCollection(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));
   }
 
-  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 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));
+  }
+
+  // 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 = {
-  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;
-
-      if (element.type === "heredoc") {
-        normalDocs.push(
-          element.beging,
-          isInner || addTrailingCommas ? "," : "",
-          literalline,
-          concat(
-            path.map.apply(path, [print].concat(elementPath).concat("body"))
-          ),
-          element.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")
 };