prettier 0.21.0 → 1.0.1

data/src/nodes/operators.js

@@ -1,52 +1,83 @@
 const { concat, group, indent, line, softline } = require("../prettier");
+const { noIndent } = require("../utils");
 
-module.exports = {
-  binary: (path, opts, print) => {
-    const operator = path.getValue().body[1];
-    const useNoSpace = operator === "**";
+function printBinary(path, opts, print) {
+  const [_leftNode, operator, rightNode] = path.getValue().body;
+  const space = operator === "**" ? "" : " ";
 
+  if (noIndent.includes(rightNode.type)) {
     return group(
       concat([
         group(path.call(print, "body", 0)),
+        space,
+        operator,
+        space,
+        group(path.call(print, "body", 2))
+      ])
+    );
+  }
+
+  return group(
+    concat([
+      group(path.call(print, "body", 0)),
+      space,
+      group(
         indent(
           concat([
-            useNoSpace ? "" : " ",
-            group(
-              concat([
-                operator,
-                useNoSpace ? softline : line,
-                path.call(print, "body", 2)
-              ])
-            )
+            operator,
+            space === "" ? softline : line,
+            path.call(print, "body", 2)
           ])
         )
-      ])
-    );
-  },
-  dot2: (path, opts, print) =>
-    concat([
-      path.call(print, "body", 0),
-      "..",
-      path.getValue().body[1] ? path.call(print, "body", 1) : ""
-    ]),
-  dot3: (path, opts, print) =>
-    concat([
-      path.call(print, "body", 0),
-      "...",
-      path.getValue().body[1] ? path.call(print, "body", 1) : ""
-    ]),
-  unary: (path, opts, print) => {
-    const oper = path.getValue().body[0];
-    const doc = path.call(print, "body", 1);
-
-    if (oper === "not") {
-      // For the `not` operator, we're explicitly making the space character
-      // another element in the `concat` because there are some circumstances
-      // where we need to force parentheses (e.g., ternaries). In that case the
-      // printer for those nodes can just take out the space and put in parens.
-      return concat(["not", " ", doc]);
-    }
+      )
+    ])
+  );
+}
+
+// dot2 nodes are used with ranges (or flip-flops). They can optionally drop
+// their left side for beginless ranges or their right side for endless ranges.
+function printDot2(path, opts, print) {
+  const [leftNode, rightNode] = path.getValue().body;
+
+  return concat([
+    leftNode ? path.call(print, "body", 0) : "",
+    "..",
+    rightNode ? path.call(print, "body", 1) : ""
+  ]);
+}
+
+// dot3 nodes are used with ranges (or flip-flops). They can optionally drop
+// their left side for beginless ranges or their right side for endless ranges.
+function printDot3(path, opts, print) {
+  const [leftNode, rightNode] = path.getValue().body;
+
+  return concat([
+    leftNode ? path.call(print, "body", 0) : "",
+    "...",
+    rightNode ? path.call(print, "body", 1) : ""
+  ]);
+}
 
-    return concat([oper[0], doc]);
+function printUnary(path, opts, print) {
+  const node = path.getValue();
+  const contentsDoc = path.call(print, "body", 0);
+
+  if (node.oper === "not") {
+    // Here we defer to the original source, as it's kind of difficult to
+    // determine if we can actually remove the parentheses being used.
+    if (node.paren) {
+      return concat(["not", "(", contentsDoc, ")"]);
+    } else {
+      return concat(["not", " ", contentsDoc]);
+    }
   }
+
+  return concat([node.oper, contentsDoc]);
+}
+
+module.exports = {
+  binary: printBinary,
+  dot2: printDot2,
+  dot3: printDot3,
+  unary: printUnary
 };

data/src/nodes/params.js

@@ -1,12 +1,15 @@
-const { concat, group, join, line } = require("../prettier");
+const { concat, group, join, indent, line, softline } = require("../prettier");
 const { literal } = require("../utils");
 
-const printGenericRestParam = (symbol) => (path, opts, print) =>
-  path.getValue().body[0]
-    ? concat([symbol, path.call(print, "body", 0)])
-    : symbol;
+function printRestParam(symbol) {
+  return function printRestParamWithSymbol(path, opts, print) {
+    return path.getValue().body[0]
+      ? concat([symbol, path.call(print, "body", 0)])
+      : symbol;
+  };
+}
 
-const printParams = (path, opts, print) => {
+function printParams(path, opts, print) {
   const [
     reqs,
     optls,
@@ -61,6 +64,8 @@ const printParams = (path, opts, print) => {
     parts.push(path.call(print, "body", 6));
   }
 
+  const contents = [join(concat([",", line]), parts)];
+
   // You can put an extra comma at the end of block args between pipes to
   // change what it does. Below is the difference:
   //
@@ -70,19 +75,24 @@ const printParams = (path, opts, print) => {
   // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
   // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
   // node in the rest position. Seems odd, but it's true.
-  const comma = rest === 0 || (rest && rest.type === "excessed_comma");
+  if (rest === 0 || (rest && rest.type === "excessed_comma")) {
+    contents.push(",");
+  }
 
-  return group(concat([join(concat([",", line]), parts), comma ? "," : ""]));
-};
+  // If the parent node is a paren then we skipped printing the parentheses so
+  // that we could handle them here and get nicer formatting.
+  if (["lambda", "paren"].includes(path.getParentNode().type)) {
+    return group(
+      concat(["(", indent(concat([softline].concat(contents))), softline, ")"])
+    );
+  }
 
-const paramError = () => {
-  throw new Error("formal argument cannot be a global variable");
-};
+  return group(concat(contents));
+}
 
 module.exports = {
   args_forward: literal("..."),
-  kwrest_param: printGenericRestParam("**"),
-  rest_param: printGenericRestParam("*"),
-  params: printParams,
-  param_error: paramError
+  kwrest_param: printRestParam("**"),
+  rest_param: printRestParam("*"),
+  params: printParams
 };

data/src/nodes/patterns.js

@@ -1,43 +1,118 @@
 const { concat, group, hardline, indent, join, line } = require("../prettier");
 
-module.exports = {
-  aryptn: (path, opts, print) => {
-    const [constant, preargs, splatarg, postargs] = path.getValue().body;
-    let args = [];
+function printPatternArg(path, opts, print) {
+  // Pinning is a really special syntax in pattern matching that's not really
+  // all that well supported in ripper. Here we're just going to the original
+  // source to see if the variable is pinned.
+  if (
+    opts.originalText &&
+    opts.originalText[opts.locStart(path.getValue()) - 1] === "^"
+  ) {
+    return concat(["^", path.call(print)]);
+  }
 
-    if (preargs) {
-      args = args.concat(path.map(print, "body", 1));
-    }
+  return path.call(print);
+}
 
-    if (splatarg) {
-      args.push(concat(["*", path.call(print, "body", 2)]));
-    }
+function printAryPtn(path, opts, print) {
+  const [constant, preargs, splatarg, postargs] = path.getValue().body;
+  let args = [];
 
-    if (postargs) {
-      args = args.concat(path.map(print, "body", 3));
-    }
+  if (preargs) {
+    args = args.concat(
+      path.map((argPath) => printPatternArg(argPath, opts, print), "body", 1)
+    );
+  }
 
-    args = group(join(concat([",", line]), args));
+  if (splatarg) {
+    args.push(concat(["*", path.call(print, "body", 2)]));
+  }
 
-    if (constant || path.getParentNode().type === "binary") {
-      args = concat(["[", args, "]"]);
-    }
+  if (postargs) {
+    args = args.concat(path.map(print, "body", 3));
+  }
 
-    if (constant) {
-      return concat([path.call(print, "body", 0), args]);
-    }
+  args = group(join(concat([",", line]), args));
 
-    return args;
-  },
-  hshptn: () => {
-    throw new Error(
-      "Hash pattern not currently supported (https://bugs.ruby-lang.org/issues/16008)"
-    );
-  },
-  in: (path, opts, print) =>
-    concat([
-      "in ",
-      path.call(print, "body", 0),
-      indent(concat([hardline, path.call(print, "body", 1)]))
-    ])
+  if (
+    constant ||
+    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
+  ) {
+    args = concat(["[", args, "]"]);
+  }
+
+  if (constant) {
+    return concat([path.call(print, "body", 0), args]);
+  }
+
+  return args;
+}
+
+function printHshPtn(path, opts, print) {
+  const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
+  let args = [];
+
+  if (keyValuePairs) {
+    const printPair = (pairPath) => {
+      const parts = [pairPath.call(print, 0)];
+
+      if (pairPath.getValue()[1]) {
+        parts.push(
+          " ",
+          pairPath.call(
+            (pairValuePath) => printPatternArg(pairValuePath, opts, print),
+            1
+          )
+        );
+      }
+
+      return concat(parts);
+    };
+
+    args = args.concat(path.map(printPair, "body", 1));
+  }
+
+  if (keyValueRest) {
+    args.push(concat(["**", path.call(print, "body", 2)]));
+  }
+
+  args = group(join(concat([",", line]), args));
+
+  if (constant) {
+    args = concat(["[", args, "]"]);
+  } else if (
+    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
+  ) {
+    args = concat(["{", args, "}"]);
+  }
+
+  if (constant) {
+    return concat([path.call(print, "body", 0), args]);
+  }
+
+  return args;
+}
+
+function printIn(path, opts, print) {
+  const parts = [
+    "in ",
+    path.call(
+      (valuePath) => printPatternArg(valuePath, opts, print),
+      "body",
+      0
+    ),
+    indent(concat([hardline, path.call(print, "body", 1)]))
+  ];
+
+  if (path.getValue().body[2]) {
+    parts.push(hardline, path.call(print, "body", 2));
+  }
+
+  return group(concat(parts));
+}
+
+module.exports = {
+  aryptn: printAryPtn,
+  hshptn: printHshPtn,
+  in: printIn
 };

data/src/nodes/regexp.js

@@ -1,18 +1,49 @@
 const { concat } = require("../prettier");
-const { makeList } = require("../utils");
+const { hasAncestor } = require("../utils");
 
-module.exports = {
-  regexp: makeList,
-  regexp_literal: (path, opts, print) => {
-    const [contents, ending] = path.map(print, "body");
-
-    const useBraces = contents.some(
-      (content) => typeof content === "string" && content.includes("/")
-    );
-    const parts = [useBraces ? "%r{" : "/"]
-      .concat(contents)
-      .concat([useBraces ? "}" : "/", ending.slice(1)]);
-
-    return concat(parts);
+function isStringContent(node) {
+  return node.type === "@tstring_content";
+}
+
+function shouldUseBraces(path) {
+  const node = path.getValue();
+  const first = node.body[0];
+
+  // If the first part of this regex is plain string content and we have a
+  // space or an =, then we want to use braces because otherwise we could end up
+  // with an ambiguous operator, e.g. foo / bar/ or foo /=bar/
+  if (
+    first &&
+    isStringContent(first) &&
+    [" ", "="].includes(first.body[0]) &&
+    hasAncestor(path, ["command", "command_call"])
+  ) {
+    return true;
   }
+
+  return node.body.some(
+    (child) => isStringContent(child) && child.body.includes("/")
+  );
+}
+
+// This function is responsible for printing out regexp_literal nodes. They can
+// either use the special %r literal syntax or they can use forward slashes. At
+// the end of either of those they can have modifiers like m or x that have
+// special meaning for the regex engine.
+//
+// We favor the use of forward slashes unless the regex contains a forward slash
+// itself. In that case we switch over to using %r with braces.
+function printRegexpLiteral(path, opts, print) {
+  const node = path.getValue();
+  const useBraces = shouldUseBraces(path);
+
+  const parts = [useBraces ? "%r{" : "/"]
+    .concat(path.map(print, "body"))
+    .concat([useBraces ? "}" : "/", node.ending.slice(1)]);
+
+  return concat(parts);
+}
+
+module.exports = {
+  regexp_literal: printRegexpLiteral
 };

data/src/nodes/rescue.js

@@ -9,73 +9,86 @@ const {
 } = require("../prettier");
 const { literal } = require("../utils");
 
-module.exports = {
-  begin: (path, opts, print) =>
-    concat([
-      "begin",
-      indent(concat([hardline, concat(path.map(print, "body"))])),
-      hardline,
-      "end"
-    ]),
-  ensure: (path, opts, print) =>
-    concat([
-      "ensure",
-      indent(concat([hardline, concat(path.map(print, "body"))]))
-    ]),
-  redo: literal("redo"),
-  rescue: (path, opts, print) => {
-    const [exception, variable, _stmts, addition] = path.getValue().body;
-    const parts = ["rescue"];
+function printBegin(path, opts, print) {
+  return concat([
+    "begin",
+    indent(concat([hardline, concat(path.map(print, "body"))])),
+    hardline,
+    "end"
+  ]);
+}
 
-    if (exception || variable) {
-      if (exception) {
-        if (Array.isArray(exception)) {
-          // In this case, it's actually only the one exception (it's an array
-          // of length 1).
-          parts.push(" ", path.call(print, "body", 0, 0));
-        } else {
-          // Here we have multiple exceptions from which we're rescuing, so we
-          // need to align them and join them together.
-          const joiner = concat([",", line]);
-          const exceptions = group(join(joiner, path.call(print, "body", 0)));
+function printEnsure(path, opts, print) {
+  return concat([
+    path.call(print, "body", 0),
+    indent(concat([hardline, path.call(print, "body", 1)]))
+  ]);
+}
 
-          parts.push(" ", align("rescue ".length, exceptions));
-        }
-      }
+function printRescue(path, opts, print) {
+  const [exception, variable, _stmts, addition] = path.getValue().body;
+  const parts = ["rescue"];
+
+  if (exception || variable) {
+    if (exception) {
+      if (Array.isArray(exception)) {
+        // In this case, it's actually only the one exception (it's an array
+        // of length 1).
+        parts.push(" ", path.call(print, "body", 0, 0));
+      } else {
+        // Here we have multiple exceptions from which we're rescuing, so we
+        // need to align them and join them together.
+        const joiner = concat([",", line]);
+        const exceptions = group(join(joiner, path.call(print, "body", 0)));
 
-      if (variable) {
-        parts.push(" => ", path.call(print, "body", 1));
+        parts.push(" ", align("rescue ".length, exceptions));
       }
-    } else {
-      // If you don't specify an error to rescue in a `begin/rescue` block, then
-      // implicitly you're rescuing from `StandardError`. In this case, we're
-      // just going to explicitly add it.
-      parts.push(" StandardError");
     }
 
-    const rescueBody = path.call(print, "body", 2);
-
-    if (rescueBody.parts.length > 0) {
-      parts.push(indent(concat([hardline, rescueBody])));
+    if (variable) {
+      parts.push(" => ", path.call(print, "body", 1));
     }
+  } else {
+    // If you don't specify an error to rescue in a `begin/rescue` block, then
+    // implicitly you're rescuing from `StandardError`. In this case, we're
+    // just going to explicitly add it.
+    parts.push(" StandardError");
+  }
 
-    // This is the next clause on the `begin` statement, either another
-    // `rescue`, and `ensure`, or an `else` clause.
-    if (addition) {
-      parts.push(concat([hardline, path.call(print, "body", 3)]));
-    }
+  const rescueBody = path.call(print, "body", 2);
+
+  if (rescueBody.parts.length > 0) {
+    parts.push(indent(concat([hardline, rescueBody])));
+  }
 
-    return group(concat(parts));
-  },
-  rescue_mod: (path, opts, print) =>
-    concat([
-      "begin",
-      indent(concat([hardline, path.call(print, "body", 0)])),
-      hardline,
-      "rescue StandardError",
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      hardline,
-      "end"
-    ]),
+  // This is the next clause on the `begin` statement, either another
+  // `rescue`, and `ensure`, or an `else` clause.
+  if (addition) {
+    parts.push(concat([hardline, path.call(print, "body", 3)]));
+  }
+
+  return group(concat(parts));
+}
+
+function printRescueMod(path, opts, print) {
+  const [statementDoc, valueDoc] = path.map(print, "body");
+
+  return concat([
+    "begin",
+    indent(concat([hardline, statementDoc])),
+    hardline,
+    "rescue StandardError",
+    indent(concat([hardline, valueDoc])),
+    hardline,
+    "end"
+  ]);
+}
+
+module.exports = {
+  begin: printBegin,
+  ensure: printEnsure,
+  redo: literal("redo"),
+  rescue: printRescue,
+  rescue_mod: printRescueMod,
   retry: literal("retry")
 };