prettier 1.2.0 → 1.2.5

data/src/{nodes → ruby/nodes}/conditionals.js

@@ -7,10 +7,10 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
+} = require("../../prettier");
 
-const { containsAssignment, isEmptyStmts } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([

data/src/{nodes → ruby/nodes}/constants.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, softline } = require("../prettier");
-const { makeCall } = require("../utils");
+const { concat, group, indent, join, softline } = require("../../prettier");
+const { makeCall } = require("../../utils");
 
 function printConstPath(path, opts, print) {
   return join("::", path.map(print, "body"));

data/src/{nodes → ruby/nodes}/flow.js

@@ -1,5 +1,5 @@
-const { concat, join } = require("../prettier");
-const { literal } = require("../utils");
+const { concat, join } = require("../../prettier");
+const { literal } = require("../../utils");
 
 const nodeDive = (node, steps) => {
   let current = node;

data/src/{nodes → ruby/nodes}/hashes.js

@@ -1,11 +1,16 @@
-const { concat, group, ifBreak, indent, join, line } = require("../prettier");
-
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line
+} = require("../../prettier");
 const {
   getTrailingComma,
-  prefix,
   printEmptyCollection,
   skipAssignIndent
-} = require("../utils");
+} = 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
@@ -49,8 +54,20 @@ function printHashKeyLabel(path, print) {
       return print(path);
     case "symbol_literal":
       return concat([path.call(print, "body", 0), ":"]);
-    case "dyna_symbol":
-      return concat(print(path).parts.slice(1).concat(":"));
+    case "dyna_symbol": {
+      const { parts } = print(path);
+
+      // We're going to slice off the starting colon character so that we can
+      // move it to the end. If there are comments, then we're going to go
+      // further into the printed doc nodes.
+      if (parts[0] === ":") {
+        parts.splice(0, 1);
+      } else {
+        parts[1].parts.splice(0, 1);
+      }
+
+      return concat(parts.concat(":"));
+    }
   }
 }
 
@@ -66,20 +83,25 @@ function printHashKeyRocket(path, print) {
 }
 
 function printAssocNew(path, opts, print) {
+  const [keyNode, valueNode] = path.getValue().body;
   const { keyPrinter } = path.getParentNode();
 
   const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
   const valueDoc = path.call(print, "body", 1);
 
-  if (skipAssignIndent(path.getValue().body[1])) {
-    parts.push(" ", valueDoc);
-  } else {
+  if (!skipAssignIndent(valueNode) || keyNode.comments) {
     parts.push(indent(concat([line, valueDoc])));
+  } else {
+    parts.push(" ", valueDoc);
   }
 
   return group(concat(parts));
 }
 
+function printAssocSplat(path, opts, print) {
+  return concat(["**", path.call(print, "body", 0)]);
+}
+
 function printHashContents(path, opts, print) {
   const node = path.getValue();
 
@@ -121,7 +143,7 @@ function printHash(path, opts, print) {
 
 module.exports = {
   assoc_new: printAssocNew,
-  assoc_splat: prefix("**"),
+  assoc_splat: printAssocSplat,
   assoclist_from_args: printHashContents,
   bare_assoc_hash: printHashContents,
   hash: printHash

data/src/{nodes → ruby/nodes}/heredocs.js

@@ -1,5 +1,5 @@
-const { concat, group, lineSuffix, join } = require("../prettier");
-const { literalLineNoBreak } = require("../utils");
+const { concat, group, lineSuffix, join } = require("../../prettier");
+const { literalLineNoBreak } = require("../../utils");
 
 function printHeredoc(path, opts, print) {
   const { body, ending } = path.getValue();

data/src/ruby/nodes/hooks.js

@@ -0,0 +1,34 @@
+const { concat, group, indent, line } = require("../../prettier");
+
+// The `BEGIN` and `END` keywords are used to hook into the Ruby process. Any
+// `BEGIN` blocks are executed right when the process starts up, and the `END`
+// blocks are executed right before exiting.
+//
+//     BEGIN {
+//       # content goes here
+//     }
+//
+//     END {
+//       # content goes here
+//     }
+//
+// Interesting side note, you don't use `do...end` blocks with these hooks. Both
+// nodes contain one child which is a `stmts` node.
+function printHook(name) {
+  return function printHookWithName(path, opts, print) {
+    return group(
+      concat([
+        name,
+        " ",
+        path.call(print, "body", 0),
+        indent(concat([line, path.call(print, "body", 1)])),
+        concat([line, "}"])
+      ])
+    );
+  };
+}
+
+module.exports = {
+  BEGIN: printHook("BEGIN"),
+  END: printHook("END")
+};

data/src/{nodes → ruby/nodes}/lambdas.js

@@ -1,5 +1,5 @@
-const { concat, group, ifBreak, indent, line } = require("../prettier");
-const { hasAncestor } = require("../utils");
+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,
 // or if we have them wrapped in parens then they'll be one level deeper. Even

data/src/{nodes → ruby/nodes}/loops.js

@@ -6,11 +6,12 @@ const {
   hardline,
   ifBreak,
   indent,
+  join,
   softline
-} = require("../prettier");
+} = require("../../prettier");
 
-const { containsAssignment } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
+const { containsAssignment } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 function printLoop(keyword, modifier) {
   return function printLoopWithOptions(path, { rubyModifier }, print) {
@@ -78,15 +79,17 @@ function printLoop(keyword, modifier) {
 }
 
 function printFor(path, opts, print) {
-  const [variable, range, stmts] = path.map(print, "body");
+  const [varDoc, rangeDoc, stmtsDoc] = path.map(print, "body");
+  const varsDoc =
+    path.getValue().body[0].type === "mlhs" ? join(", ", varDoc) : varDoc;
 
   return group(
     concat([
       "for ",
-      variable,
+      varsDoc,
       " in ",
-      range,
-      indent(concat([hardline, stmts])),
+      rangeDoc,
+      indent(concat([hardline, stmtsDoc])),
       concat([hardline, "end"])
     ])
   );

data/src/{nodes → ruby/nodes}/massign.js

@@ -1,4 +1,11 @@
-const { concat, group, indent, join, line, softline } = require("../prettier");
+const {
+  concat,
+  group,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
 
 function printMAssign(path, opts, print) {
   let right = path.call(print, "body", 1);

data/src/{nodes → ruby/nodes}/methods.js

@@ -1,5 +1,4 @@
-const { concat, group, hardline, indent, line } = require("../prettier");
-const { first } = require("../utils");
+const { concat, group, hardline, indent, line } = require("../../prettier");
 
 function printMethod(offset) {
   return function printMethodWithOffset(path, opts, print) {
@@ -16,8 +15,7 @@ function printMethod(offset) {
     }
 
     // In case there are no parens but there are arguments
-    const parens =
-      params.type === "params" && params.body.some((paramType) => paramType);
+    const parens = params.type === "params" && params.body.some((type) => type);
 
     declaration.push(
       path.call(print, "body", offset),
@@ -49,15 +47,34 @@ function printMethod(offset) {
 }
 
 function printSingleLineMethod(path, opts, print) {
-  const [nameDoc, stmtDoc] = path.map(print, "body");
+  let parensNode = path.getValue().body[1];
+  let paramsDoc = "";
+
+  if (parensNode) {
+    const paramsNode = parensNode.body[0];
+
+    if (paramsNode.body.some((type) => type)) {
+      paramsDoc = path.call(print, "body", 1);
+    }
+  }
 
   return group(
-    concat(["def ", nameDoc, " =", indent(group(concat([line, stmtDoc])))])
+    concat([
+      "def ",
+      path.call(print, "body", 0),
+      paramsDoc,
+      " =",
+      indent(group(concat([line, path.call(print, "body", 2)])))
+    ])
   );
 }
 
+function printAccessControl(path, opts, print) {
+  return path.call(print, "body", 0);
+}
+
 module.exports = {
-  access_ctrl: first,
+  access_ctrl: printAccessControl,
   def: printMethod(0),
   defs: printMethod(2),
   defsl: printSingleLineMethod

data/src/{nodes → ruby/nodes}/operators.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, line, softline } = require("../prettier");
-const { noIndent } = require("../utils");
+const { concat, group, indent, line, softline } = require("../../prettier");
+const { noIndent } = require("../../utils");
 
 function printBinary(path, opts, print) {
   const [_leftNode, operator, rightNode] = path.getValue().body;

data/src/{nodes → ruby/nodes}/params.js

@@ -1,5 +1,12 @@
-const { concat, group, join, indent, line, softline } = require("../prettier");
-const { literal } = require("../utils");
+const {
+  concat,
+  group,
+  join,
+  indent,
+  line,
+  softline
+} = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printRestParam(symbol) {
   return function printRestParamWithSymbol(path, opts, print) {
@@ -22,18 +29,22 @@ function printParams(path, opts, print) {
   let parts = [];
 
   if (reqs) {
-    parts = parts.concat(path.map(print, "body", 0));
+    path.each(
+      (reqPath) => {
+        // For some very strange reason, if you have a comment attached to a
+        // rest_param, it shows up here in the list of required params.
+        if (reqPath.getValue().type !== "rest_param") {
+          parts.push(print(reqPath));
+        }
+      },
+      "body",
+      0
+    );
   }
 
   if (optls) {
     parts = parts.concat(
-      optls.map((_, index) =>
-        concat([
-          path.call(print, "body", 1, index, 0),
-          " = ",
-          path.call(print, "body", 1, index, 1)
-        ])
-      )
+      path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1)
     );
   }
 
@@ -47,12 +58,16 @@ function printParams(path, opts, print) {
 
   if (kwargs) {
     parts = parts.concat(
-      kwargs.map(([, value], index) => {
-        if (!value) {
-          return path.call(print, "body", 4, index, 0);
-        }
-        return group(join(" ", path.map(print, "body", 4, index)));
-      })
+      path.map(
+        (kwargPath) => {
+          if (!kwargPath.getValue()[1]) {
+            return kwargPath.call(print, 0);
+          }
+          return group(join(" ", kwargPath.map(print)));
+        },
+        "body",
+        4
+      )
     );
   }
 

data/src/{nodes → ruby/nodes}/patterns.js

@@ -1,4 +1,14 @@
-const { concat, group, hardline, indent, join, line } = require("../prettier");
+const {
+  align,
+  concat,
+  group,
+  hardline,
+  indent,
+  join,
+  line
+} = require("../../prettier");
+
+const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
 
 function printPatternArg(path, opts, print) {
   // Pinning is a really special syntax in pattern matching that's not really
@@ -34,10 +44,7 @@ function printAryPtn(path, opts, print) {
 
   args = group(join(concat([",", line]), args));
 
-  if (
-    constant ||
-    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
-  ) {
+  if (constant || patterns.includes(path.getParentNode().type)) {
     args = concat(["[", args, "]"]);
   }
 
@@ -51,9 +58,9 @@ function printAryPtn(path, opts, print) {
 function printFndPtn(path, opts, print) {
   const [constant] = path.getValue().body;
 
-  let args = [path.call(print, "body", 1)]
+  let args = [concat(["*", path.call(print, "body", 1)])]
     .concat(path.map(print, "body", 2))
-    .concat(path.call(print, "body", 3));
+    .concat(concat(["*", path.call(print, "body", 3)]));
 
   args = concat(["[", group(join(concat([",", line]), args)), "]"]);
 
@@ -68,7 +75,7 @@ function printHshPtn(path, opts, print) {
   const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
   let args = [];
 
-  if (keyValuePairs) {
+  if (keyValuePairs.length > 0) {
     const printPair = (pairPath) => {
       const parts = [pairPath.call(print, 0)];
 
@@ -96,10 +103,8 @@ function printHshPtn(path, opts, print) {
 
   if (constant) {
     args = concat(["[", args, "]"]);
-  } else if (
-    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
-  ) {
-    args = concat(["{", args, "}"]);
+  } else if (patterns.includes(path.getParentNode().type)) {
+    args = concat(["{ ", args, " }"]);
   }
 
   if (constant) {
@@ -112,10 +117,13 @@ function printHshPtn(path, opts, print) {
 function printIn(path, opts, print) {
   const parts = [
     "in ",
-    path.call(
-      (valuePath) => printPatternArg(valuePath, opts, print),
-      "body",
-      0
+    align(
+      "in ".length,
+      path.call(
+        (valuePath) => printPatternArg(valuePath, opts, print),
+        "body",
+        0
+      )
     ),
     indent(concat([hardline, path.call(print, "body", 1)]))
   ];
@@ -127,9 +135,23 @@ function printIn(path, opts, print) {
   return group(concat(parts));
 }
 
+function printRAssign(path, opts, print) {
+  const { keyword } = path.getValue();
+  const [leftDoc, rightDoc] = path.map(print, "body");
+
+  return group(
+    concat([
+      leftDoc,
+      keyword ? " in" : " =>",
+      group(indent(concat([line, rightDoc])))
+    ])
+  );
+}
+
 module.exports = {
   aryptn: printAryPtn,
   fndptn: printFndPtn,
   hshptn: printHshPtn,
-  in: printIn
+  in: printIn,
+  rassign: printRAssign
 };