prettier 1.2.2 → 1.4.0

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) {
@@ -48,15 +47,13 @@ function printMethod(offset) {
 }
 
 function printSingleLineMethod(path, opts, print) {
-  let paramsNode = path.getValue().body[1];
+  let parensNode = path.getValue().body[1];
   let paramsDoc = "";
 
-  if (paramsNode) {
-    if (paramsNode.body[0].type === "params") {
-      paramsNode = paramsNode.body[0];
-    }
+  if (parensNode) {
+    const paramsNode = parensNode.body[0];
 
-    if (paramsNode.type === "params" && paramsNode.body.some((type) => type)) {
+    if (paramsNode.body.some((type) => type)) {
       paramsDoc = path.call(print, "body", 1);
     }
   }
@@ -72,8 +69,12 @@ function printSingleLineMethod(path, opts, print) {
   );
 }
 
+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,12 @@
-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"];
 
@@ -67,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)];
 
@@ -109,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)]))
   ];

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

@@ -1,5 +1,5 @@
-const { concat } = require("../prettier");
-const { hasAncestor } = require("../utils");
+const { concat } = require("../../prettier");
+const { hasAncestor } = require("../../utils");
 
 function hasContent(node, pattern) {
   return node.body.some(

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

@@ -6,8 +6,8 @@ const {
   indent,
   join,
   line
-} = require("../prettier");
-const { literal } = require("../utils");
+} = require("../../prettier");
+const { literal } = require("../../utils");
 
 function printBegin(path, opts, print) {
   return concat([
@@ -26,28 +26,10 @@ function printEnsure(path, opts, print) {
 }
 
 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)));
-
-        parts.push(" ", align("rescue ".length, exceptions));
-      }
-    }
-
-    if (variable) {
-      parts.push(" => ", path.call(print, "body", 1));
-    }
+  if (path.getValue().body[0]) {
+    parts.push(align("rescue ".length, path.call(print, "body", 0)));
   } 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
@@ -55,16 +37,40 @@ function printRescue(path, opts, print) {
     parts.push(" StandardError");
   }
 
-  const rescueBody = path.call(print, "body", 2);
+  const bodystmt = path.call(print, "body", 1);
 
-  if (rescueBody.parts.length > 0) {
-    parts.push(indent(concat([hardline, rescueBody])));
+  if (bodystmt.parts.length > 0) {
+    parts.push(indent(concat([hardline, bodystmt])));
   }
 
   // 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)]));
+  if (path.getValue().body[2]) {
+    parts.push(concat([hardline, path.call(print, "body", 2)]));
+  }
+
+  return group(concat(parts));
+}
+
+// This is a container node that we're adding into the AST that isn't present in
+// Ripper solely so that we have a nice place to attach inline comments.
+function printRescueEx(path, opts, print) {
+  const [exception, variable] = path.getValue().body;
+  const parts = [];
+
+  if (exception) {
+    let exceptionDoc = path.call(print, "body", 0);
+
+    if (Array.isArray(exceptionDoc)) {
+      const joiner = concat([",", line]);
+      exceptionDoc = group(join(joiner, exceptionDoc));
+    }
+
+    parts.push(" ", exceptionDoc);
+  }
+
+  if (variable) {
+    parts.push(" => ", path.call(print, "body", 1));
   }
 
   return group(concat(parts));
@@ -89,6 +95,7 @@ module.exports = {
   ensure: printEnsure,
   redo: literal("redo"),
   rescue: printRescue,
+  rescue_ex: printRescueEx,
   rescue_mod: printRescueMod,
   retry: literal("retry")
 };