prettier 1.0.0.pre.rc1 → 1.2.0

data/src/nodes/ints.js

@@ -12,12 +12,6 @@
 function printInt(path, _opts, _print) {
   const { body } = path.getValue();
 
-  // If the number is octal and does not contain the optional "o" character
-  // after the leading 0, add it in.
-  if (/^0[0-9]/.test(body)) {
-    return `0o${body.slice(1)}`;
-  }
-
   // If the number is a base 10 number, is sufficiently large, and is not
   // already formatted with underscores, then add them in in between the
   // numbers every three characters starting from the right.

data/src/nodes/lambdas.js

@@ -1,11 +1,4 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  line,
-  softline
-} = require("../prettier");
+const { concat, group, ifBreak, indent, line } = require("../prettier");
 const { hasAncestor } = require("../utils");
 
 // We can have our params coming in as the first child of the main lambda node,
@@ -13,31 +6,22 @@ const { hasAncestor } = require("../utils");
 // though it's possible to omit the parens if you only have one argument, we're
 // going to keep them in no matter what for consistency.
 function printLambdaParams(path, print) {
-  const paramsPath = [print, "body", 0];
-  let paramsNode = path.getValue().body[0];
+  let node = path.getValue().body[0];
 
   // In this case we had something like -> (foo) { bar } which would mean that
   // we're looking at a paren node, so we'll descend one level deeper to get at
   // the actual params node.
-  if (paramsNode.type !== "params") {
-    paramsPath.push("body", 0);
-    paramsNode = paramsNode.body[0];
+  if (node.type !== "params") {
+    node = node.body[0];
   }
 
   // If we don't have any params at all, then we're just going to bail out and
   // print nothing. This is to avoid printing an empty set of parentheses.
-  if (paramsNode.body.every((type) => !type)) {
+  if (node.body.every((type) => !type)) {
     return "";
   }
 
-  return group(
-    concat([
-      "(",
-      indent(concat([softline, path.call.apply(path, paramsPath)])),
-      softline,
-      ")"
-    ])
-  );
+  return path.call(print, "body", 0);
 }
 
 // Lambda nodes represent stabby lambda literals, which can come in a couple of

data/src/nodes/loops.js

@@ -12,85 +12,85 @@ const {
 const { containsAssignment } = require("../utils");
 const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
-const printLoop = (keyword, modifier) => (path, { rubyModifier }, print) => {
-  const [_predicate, stmts] = path.getValue().body;
+function printLoop(keyword, modifier) {
+  return function printLoopWithOptions(path, { rubyModifier }, print) {
+    const [_predicate, stmts] = path.getValue().body;
 
-  // If the only statement inside this while loop is a void statement, then we
-  // can shorten to just displaying the predicate and then a semicolon.
-  if (
-    stmts.body.length === 1 &&
-    stmts.body[0].type === "void_stmt" &&
-    !stmts.body[0].comments
-  ) {
-    return group(
-      concat([
-        keyword,
-        " ",
-        path.call(print, "body", 0),
-        ifBreak(softline, "; "),
-        "end"
+    // If the only statement inside this while loop is a void statement, then we
+    // can shorten to just displaying the predicate and then a semicolon.
+    if (
+      stmts.body.length === 1 &&
+      stmts.body[0].type === "void_stmt" &&
+      !stmts.body[0].comments
+    ) {
+      return group(
+        concat([
+          keyword,
+          " ",
+          path.call(print, "body", 0),
+          ifBreak(softline, "; "),
+          "end"
+        ])
+      );
+    }
+
+    const inlineLoop = concat(
+      inlineEnsureParens(path, [
+        path.call(print, "body", 1),
+        ` ${keyword} `,
+        path.call(print, "body", 0)
       ])
     );
-  }
 
-  const inlineLoop = concat(
-    inlineEnsureParens(path, [
-      path.call(print, "body", 1),
-      ` ${keyword} `,
-      path.call(print, "body", 0)
-    ])
-  );
+    // If we're in the modifier form and we're modifying a `begin`, then this is
+    // a special case where we need to explicitly use the modifier form because
+    // otherwise the semantic meaning changes. This looks like:
+    //
+    //     begin
+    //       foo
+    //     end while bar
+    //
+    // The above is effectively a `do...while` loop (which we don't have in
+    // ruby).
+    if (modifier && path.getValue().body[1].type === "begin") {
+      return inlineLoop;
+    }
 
-  // If we're in the modifier form and we're modifying a `begin`, then this is a
-  // special case where we need to explicitly use the modifier form because
-  // otherwise the semantic meaning changes. This looks like:
-  //
-  //     begin
-  //       foo
-  //     end while bar
-  //
-  // The above is effectively a `do...while` loop (which we don't have in ruby).
-  if (modifier && path.getValue().body[1].type === "begin") {
-    return inlineLoop;
-  }
+    const blockLoop = concat([
+      concat([
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0))
+      ]),
+      indent(concat([softline, path.call(print, "body", 1)])),
+      concat([softline, "end"])
+    ]);
 
-  const blockLoop = concat([
-    concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0))
-    ]),
-    indent(concat([softline, path.call(print, "body", 1)])),
-    concat([softline, "end"])
-  ]);
+    // If we're disallowing inline loops or if the predicate of the loop
+    // contains an assignment (in which case we can't know for certain that that
+    // assignment doesn't impact the statements inside the loop) then we can't
+    // use the modifier form and we must use the block form.
+    if (!rubyModifier || containsAssignment(path.getValue().body[0])) {
+      return concat([breakParent, blockLoop]);
+    }
 
-  // If we're disallowing inline loops or if the predicate of the loop contains
-  // an assignment (in which case we can't know for certain that that
-  // assignment doesn't impact the statements inside the loop) then we can't
-  // use the modifier form and we must use the block form.
-  if (!rubyModifier || containsAssignment(path.getValue().body[0])) {
-    return concat([breakParent, blockLoop]);
-  }
+    return group(ifBreak(blockLoop, inlineLoop));
+  };
+}
 
-  return group(ifBreak(blockLoop, inlineLoop));
-};
+function printFor(path, opts, print) {
+  const [variable, range, stmts] = path.map(print, "body");
 
-// Technically this is incorrect. A `for` loop actually introduces and modifies
-// a local variable that then remains in the outer scope. Additionally, if the
-// `each` method was somehow missing from the enumerable (it's possible...),
-// then this transformation would fail. However - I've never actually seen a
-// `for` loop used in production. If someone actually calls me on it, I'll fix
-// this, but for now I'm leaving it.
-const printFor = (path, opts, print) =>
-  group(
+  return group(
     concat([
-      path.call(print, "body", 1),
-      ".each do |",
-      path.call(print, "body", 0),
-      "|",
-      indent(concat([hardline, path.call(print, "body", 2)])),
+      "for ",
+      variable,
+      " in ",
+      range,
+      indent(concat([hardline, stmts])),
       concat([hardline, "end"])
     ])
   );
+}
 
 module.exports = {
   while: printLoop("while", false),

data/src/nodes/methods.js

@@ -1,4 +1,4 @@
-const { concat, group, hardline, indent } = require("../prettier");
+const { concat, group, hardline, indent, line } = require("../prettier");
 const { first } = require("../utils");
 
 function printMethod(offset) {
@@ -48,8 +48,17 @@ function printMethod(offset) {
   };
 }
 
+function printSingleLineMethod(path, opts, print) {
+  const [nameDoc, stmtDoc] = path.map(print, "body");
+
+  return group(
+    concat(["def ", nameDoc, " =", indent(group(concat([line, stmtDoc])))])
+  );
+}
+
 module.exports = {
   access_ctrl: first,
   def: printMethod(0),
-  defs: printMethod(2)
+  defs: printMethod(2),
+  defsl: printSingleLineMethod
 };

data/src/nodes/params.js

@@ -1,4 +1,4 @@
-const { concat, group, join, line } = require("../prettier");
+const { concat, group, join, indent, line, softline } = require("../prettier");
 const { literal } = require("../utils");
 
 function printRestParam(symbol) {
@@ -64,6 +64,8 @@ function 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:
   //
@@ -73,9 +75,19 @@ function 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(",");
+  }
+
+  // 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, ")"])
+    );
+  }
 
-  return group(concat([join(concat([",", line]), parts), comma ? "," : ""]));
+  return group(concat(contents));
 }
 
 module.exports = {

data/src/nodes/patterns.js

@@ -48,6 +48,22 @@ function printAryPtn(path, opts, print) {
   return args;
 }
 
+function printFndPtn(path, opts, print) {
+  const [constant] = path.getValue().body;
+
+  let args = [path.call(print, "body", 1)]
+    .concat(path.map(print, "body", 2))
+    .concat(path.call(print, "body", 3));
+
+  args = concat(["[", group(join(concat([",", line]), 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 = [];
@@ -113,6 +129,7 @@ function printIn(path, opts, print) {
 
 module.exports = {
   aryptn: printAryPtn,
+  fndptn: printFndPtn,
   hshptn: printHshPtn,
   in: printIn
 };

data/src/nodes/regexp.js

@@ -1,21 +1,25 @@
 const { concat } = require("../prettier");
+const { hasAncestor } = require("../utils");
 
-function isStringContent(node) {
-  return node.type === "@tstring_content";
+function hasContent(node, pattern) {
+  return node.body.some(
+    (child) => child.type === "@tstring_content" && pattern.test(child.body)
+  );
 }
 
-function shouldUseBraces(node) {
-  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])) {
-    return true;
-  }
+// If the first part of this regex is plain string content, we have a space
+// or an =, and we're contained within a command or command_call node, then we
+// want to use braces because otherwise we could end up with an ambiguous
+// operator, e.g. foo / bar/ or foo /=bar/
+function forwardSlashIsAmbiguous(path) {
+  const node = path.getValue();
+  const firstChildNode = node.body[0];
 
-  return node.body.some(
-    (child) => isStringContent(child) && child.body.includes("/")
+  return (
+    firstChildNode &&
+    firstChildNode.type === "@tstring_content" &&
+    [" ", "="].includes(firstChildNode.body[0]) &&
+    hasAncestor(path, ["command", "command_call"])
   );
 }
 
@@ -28,13 +32,23 @@ function shouldUseBraces(node) {
 // itself. In that case we switch over to using %r with braces.
 function printRegexpLiteral(path, opts, print) {
   const node = path.getValue();
-  const useBraces = shouldUseBraces(node);
+  const docs = path.map(print, "body");
+
+  // We should use braces if using a forward slash would be ambiguous in the
+  // current context or if there's a forward slash in the content of the regexp.
+  const useBraces = forwardSlashIsAmbiguous(path) || hasContent(node, /\//);
 
-  const parts = [useBraces ? "%r{" : "/"]
-    .concat(path.map(print, "body"))
-    .concat([useBraces ? "}" : "/", node.ending.slice(1)]);
+  // If we should be using braces but we have braces in the body of the regexp,
+  // then we're just going to resort to using whatever the original content was.
+  if (useBraces && hasContent(node, /[{}]/)) {
+    return concat([node.beging].concat(docs).concat(node.ending));
+  }
 
-  return concat(parts);
+  return concat(
+    [useBraces ? "%r{" : "/"]
+      .concat(docs)
+      .concat(useBraces ? "}" : "/", node.ending.slice(1))
+  );
 }
 
 module.exports = {

data/src/nodes/statements.js

@@ -45,35 +45,45 @@ function printBodyStmt(path, opts, print) {
   return group(concat(parts));
 }
 
+const argNodeTypes = ["args", "args_add_star", "args_add_block"];
+
+function printParen(path, opts, print) {
+  const contentNode = path.getValue().body[0];
+
+  if (!contentNode) {
+    return "()";
+  }
+
+  let contentDoc = path.call(print, "body", 0);
+
+  // If the content is params, we're going to let it handle its own parentheses
+  // so that it breaks nicely.
+  if (contentNode.type === "params") {
+    return contentDoc;
+  }
+
+  // If we have an arg type node as the contents, then it's going to return an
+  // array, so we need to explicitly join that content here.
+  if (argNodeTypes.includes(contentNode.type)) {
+    contentDoc = join(concat([",", line]), contentDoc);
+  }
+
+  return group(
+    concat([
+      "(",
+      indent(concat([softline, contentDoc])),
+      concat([softline, ")"])
+    ])
+  );
+}
+
 module.exports = {
   "@__end__": (path, _opts, _print) => {
     const { body } = path.getValue();
     return concat([trim, "__END__", literalline, body]);
   },
   bodystmt: printBodyStmt,
-  paren: (path, opts, print) => {
-    if (!path.getValue().body[0]) {
-      return "()";
-    }
-
-    let content = path.call(print, "body", 0);
-
-    if (
-      ["args", "args_add_star", "args_add_block"].includes(
-        path.getValue().body[0].type
-      )
-    ) {
-      content = join(concat([",", line]), content);
-    }
-
-    return group(
-      concat([
-        "(",
-        indent(concat([softline, content])),
-        concat([softline, ")"])
-      ])
-    );
-  },
+  paren: printParen,
   program: (path, opts, print) =>
     concat([join(hardline, path.map(print, "body")), hardline]),
   stmts: (path, opts, print) => {
@@ -88,8 +98,8 @@ module.exports = {
       stmts[0].comments
     ) {
       const comments = path.map(
-        (commentPath, index) => {
-          stmts[0].comments[index].printed = true;
+        (commentPath) => {
+          commentPath.getValue().printed = true;
           return opts.printer.printComment(commentPath);
         },
         "body",