prettier 0.22.0 → 1.1.0

data/src/nodes/case.js

@@ -28,13 +28,17 @@ module.exports = {
     // The `fill` builder command expects an array of docs alternating with
     // line breaks. This is so it can loop through and determine where to break.
     const preds = fill(
-      path
-        .call(print, "body", 0)
-        .reduce(
-          (accum, pred, index) =>
-            index === 0 ? [pred] : accum.concat([",", line, pred]),
-          null
-        )
+      path.call(print, "body", 0).reduce((accum, pred, index) => {
+        if (index === 0) {
+          return [pred];
+        }
+
+        // Pull off the last element and make it concat with a comma so that
+        // we can maintain alternating lines and docs.
+        return accum
+          .slice(0, -1)
+          .concat([concat([accum[accum.length - 1], ","]), line, pred]);
+      }, null)
     );
 
     const stmts = path.call(print, "body", 1);

data/src/nodes/conditionals.js

@@ -81,7 +81,7 @@ const printTernary = (path, _opts, print) => {
 // modifier form, we're guaranteed to not have an additional node, so we can
 // just work with the predicate and the body.
 function printSingle(keyword, modifier = false) {
-  return function printSingleWithKeyword(path, { inlineConditionals }, print) {
+  return function printSingleWithKeyword(path, { rubyModifier }, print) {
     const [_predicateNode, statementsNode] = path.getValue().body;
     const predicateDoc = path.call(print, "body", 0);
     const statementsDoc = path.call(print, "body", 1);
@@ -97,7 +97,7 @@ function printSingle(keyword, modifier = false) {
     // If we do not allow modifier form conditionals or there are comments
     // inside of the body of the conditional, then we must print in the
     // multiline form.
-    if (!inlineConditionals || (!modifier && statementsNode.body[0].comments)) {
+    if (!rubyModifier || (!modifier && statementsNode.body[0].comments)) {
       return concat([concat(multilineParts), breakParent]);
     }
 
@@ -190,7 +190,7 @@ const canTernary = (path) => {
 };
 
 // A normalized print function for both `if` and `unless` nodes.
-const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
+const printConditional = (keyword) => (path, { rubyModifier }, print) => {
   if (canTernary(path)) {
     let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
       printTernaryClauses(
@@ -239,7 +239,7 @@ const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
     ]);
   }
 
-  return printSingle(keyword)(path, { inlineConditionals }, print);
+  return printSingle(keyword)(path, { rubyModifier }, print);
 };
 
 module.exports = {

data/src/nodes/hashes.js

@@ -1,13 +1,11 @@
+const { concat, group, ifBreak, indent, join, line } = require("../prettier");
+
 const {
-  concat,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  join,
-  line
-} = require("../prettier");
-const { prefix, skipAssignIndent } = require("../utils");
+  getTrailingComma,
+  prefix,
+  printEmptyCollection,
+  skipAssignIndent
+} = require("../utils");
 
 // When attempting to convert a hash rocket into a hash label, you need to take
 // care because only certain patterns are allowed. Ruby source says that they
@@ -24,35 +22,54 @@ function isValidHashLabel(symbolLiteral) {
   return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
 }
 
-function printHashKey(path, { preferHashLabels }, print) {
-  const labelNode = path.getValue().body[0];
-  const labelDoc = path.call(print, "body", 0);
+function canUseHashLabels(contentsNode) {
+  return contentsNode.body.every((assocNode) => {
+    if (assocNode.type === "assoc_splat") {
+      return true;
+    }
 
-  switch (labelNode.type) {
-    case "@label":
-      if (preferHashLabels) {
-        return labelDoc;
-      }
-      return `:${labelDoc.slice(0, labelDoc.length - 1)} =>`;
-    case "symbol_literal": {
-      if (preferHashLabels && isValidHashLabel(labelNode)) {
-        return concat([path.call(print, "body", 0, "body", 0), ":"]);
-      }
-      return concat([labelDoc, " =>"]);
+    switch (assocNode.body[0].type) {
+      case "@label":
+        return true;
+      case "symbol_literal":
+        return isValidHashLabel(assocNode.body[0]);
+      case "dyna_symbol":
+        return true;
+      default:
+        return false;
     }
+  });
+}
+
+function printHashKeyLabel(path, print) {
+  const node = path.getValue();
+
+  switch (node.type) {
+    case "@label":
+      return print(path);
+    case "symbol_literal":
+      return concat([path.call(print, "body", 0), ":"]);
     case "dyna_symbol":
-      if (preferHashLabels) {
-        return concat(labelDoc.parts.slice(1).concat(":"));
-      }
-      return concat([labelDoc, " =>"]);
-    default:
-      return concat([labelDoc, " =>"]);
+      return concat(print(path).parts.slice(1).concat(":"));
   }
 }
 
+function printHashKeyRocket(path, print) {
+  const node = path.getValue();
+  const doc = print(path);
+
+  if (node.type === "@label") {
+    return `:${doc.slice(0, doc.length - 1)} =>`;
+  }
+
+  return concat([doc, " =>"]);
+}
+
 function printAssocNew(path, opts, print) {
+  const { keyPrinter } = path.getParentNode();
+
+  const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
   const valueDoc = path.call(print, "body", 1);
-  const parts = [printHashKey(path, opts, print)];
 
   if (skipAssignIndent(path.getValue().body[1])) {
     parts.push(" ", valueDoc);
@@ -63,22 +80,17 @@ function printAssocNew(path, opts, print) {
   return group(concat(parts));
 }
 
-function printEmptyHashWithComments(path, opts) {
-  const hashNode = path.getValue();
+function printHashContents(path, opts, print) {
+  const node = path.getValue();
 
-  const printComment = (commentPath, index) => {
-    hashNode.comments[index].printed = true;
-    return opts.printer.printComment(commentPath);
-  };
-
-  return concat([
-    "{",
-    indent(
-      concat([hardline, join(hardline, path.map(printComment, "comments"))])
-    ),
-    line,
-    "}"
-  ]);
+  // First determine which key printer we're going to use, so that the child
+  // nodes can reference it when they go to get printed.
+  node.keyPrinter =
+    opts.rubyHashLabel && canUseHashLabels(path.getValue())
+      ? printHashKeyLabel
+      : printHashKeyRocket;
+
+  return join(concat([",", line]), path.map(print, "body"));
 }
 
 function printHash(path, opts, print) {
@@ -88,7 +100,7 @@ function printHash(path, opts, print) {
   // missing, then it means we're dealing with an empty hash, so we can just
   // exit here and print.
   if (hashNode.body[0] === null) {
-    return hashNode.comments ? printEmptyHashWithComments(path, opts) : "{}";
+    return printEmptyCollection(path, opts, "{", "}");
   }
 
   return group(
@@ -98,7 +110,7 @@ function printHash(path, opts, print) {
         concat([
           line,
           path.call(print, "body", 0),
-          opts.addTrailingCommas ? ifBreak(",", "") : ""
+          getTrailingComma(opts) ? ifBreak(",", "") : ""
         ])
       ),
       line,
@@ -107,10 +119,6 @@ function printHash(path, opts, print) {
   );
 }
 
-function printHashContents(path, opts, print) {
-  return group(join(concat([",", line]), path.map(print, "body")));
-}
-
 module.exports = {
   assoc_new: printAssocNew,
   assoc_splat: prefix("**"),

data/src/nodes/heredocs.js

@@ -2,7 +2,7 @@ const { concat, group, lineSuffix, join } = require("../prettier");
 const { literalLineNoBreak } = require("../utils");
 
 function printHeredoc(path, opts, print) {
-  const { beging, body, ending } = path.getValue();
+  const { body, ending } = path.getValue();
 
   const parts = body.map((part, index) => {
     if (part.type !== "@tstring_content") {
@@ -21,7 +21,7 @@ function printHeredoc(path, opts, print) {
   // possible, so we use a literalline without the break-parent.
   return group(
     concat([
-      beging,
+      path.call(print, "beging"),
       lineSuffix(
         group(concat([literalLineNoBreak].concat(parts).concat(ending)))
       )

data/src/nodes/hooks.js

@@ -17,11 +17,13 @@ const { isEmptyStmts } = require("../utils");
 // nodes contain one child which is a `stmts` node.
 function printHook(name) {
   return function printHookWithName(path, opts, print) {
-    const stmtsNode = path.getValue().body[0];
-    const printedStmts = path.call(print, "body", 0);
+    const stmtsNode = path.getValue().body[1];
+    const printedStmts = path.call(print, "body", 1);
 
     const parts = [
-      `${name} {`,
+      name,
+      " ",
+      path.call(print, "body", 0),
       indent(concat([line, printedStmts])),
       concat([line, "}"])
     ];

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

@@ -1,5 +1,6 @@
 const {
   align,
+  breakParent,
   concat,
   group,
   hardline,
@@ -11,85 +12,85 @@ const {
 const { containsAssignment } = require("../utils");
 const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
-const printLoop = (keyword, modifier) => (path, { inlineLoops }, 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 (!inlineLoops || containsAssignment(path.getValue().body[0])) {
-    return 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),