prettier 0.20.0 → 1.0.0.pre.rc2

data/src/nodes/methods.js

@@ -1,80 +1,55 @@
-const {
-  align,
-  concat,
-  group,
-  hardline,
-  indent,
-  join,
-  line
-} = require("../prettier");
-const { first, literal } = require("../utils");
-
-const printMethod = (offset) => (path, opts, print) => {
-  const [_name, params, body] = path.getValue().body.slice(offset);
-  const declaration = ["def "];
-
-  // In this case, we're printing a method that's defined as a singleton, so we
-  // need to include the target and the operator
-  if (offset > 0) {
-    declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
-  }
-
-  // In case there are no parens but there are arguments
-  const parens =
-    params.type === "params" && params.body.some((paramType) => paramType);
-
-  declaration.push(
-    path.call(print, "body", offset),
-    parens ? "(" : "",
-    path.call(print, "body", offset + 1),
-    parens ? ")" : ""
-  );
+const { concat, group, hardline, indent } = require("../prettier");
+const { first } = require("../utils");
+
+function printMethod(offset) {
+  return function printMethodWithOffset(path, opts, print) {
+    const [_name, params, body] = path.getValue().body.slice(offset);
+    const declaration = ["def "];
+
+    // In this case, we're printing a method that's defined as a singleton, so
+    // we need to include the target and the operator
+    if (offset > 0) {
+      declaration.push(
+        path.call(print, "body", 0),
+        path.call(print, "body", 1)
+      );
+    }
 
-  // If the body is empty, we can replace with a ;
-  const stmts = body.body[0].body;
-  if (stmts.length === 1 && stmts[0].type === "void_stmt") {
-    return group(concat(declaration.concat(["; end"])));
-  }
+    // In case there are no parens but there are arguments
+    const parens =
+      params.type === "params" && params.body.some((paramType) => paramType);
+
+    declaration.push(
+      path.call(print, "body", offset),
+      parens ? "(" : "",
+      path.call(print, "body", offset + 1),
+      parens ? ")" : ""
+    );
+
+    // If the body is empty, we can replace with a ;
+    const stmts = body.body[0].body;
+
+    if (
+      !body.body.slice(1).some((node) => node) &&
+      stmts.length === 1 &&
+      stmts[0].type === "void_stmt" &&
+      !stmts[0].comments
+    ) {
+      return group(concat(declaration.concat(["; end"])));
+    }
 
-  return group(
-    concat([
-      group(concat(declaration)),
-      indent(concat([hardline, path.call(print, "body", offset + 2)])),
-      group(concat([hardline, "end"]))
-    ])
-  );
-};
+    return group(
+      concat([
+        group(concat(declaration)),
+        indent(concat([hardline, path.call(print, "body", offset + 2)])),
+        group(concat([hardline, "end"]))
+      ])
+    );
+  };
+}
 
 module.exports = {
   access_ctrl: first,
   def: printMethod(0),
-  defs: printMethod(2),
-  methref: (path, opts, print) => join(".:", path.map(print, "body")),
-  super: (path, opts, print) => {
-    const args = path.getValue().body[0];
-
-    if (args.type === "arg_paren") {
-      // In case there are explicitly no arguments but they are using parens,
-      // we assume they are attempting to override the initializer and pass no
-      // arguments up.
-      if (args.body[0] === null) {
-        return "super()";
-      }
-
-      return concat(["super", path.call(print, "body", 0)]);
-    }
-
-    return concat(["super ", join(", ", path.call(print, "body", 0))]);
-  },
-  undef: (path, opts, print) =>
-    group(
-      concat([
-        "undef ",
-        align(
-          "undef ".length,
-          join(concat([",", line]), path.map(print, "body", 0))
-        )
-      ])
-    ),
-  zsuper: literal("super")
+  defs: printMethod(2)
 };

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
 };