prettier 1.1.0 → 1.2.4

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, "]"]);
   }
 
@@ -48,11 +55,27 @@ function printAryPtn(path, opts, print) {
   return args;
 }
 
+function printFndPtn(path, opts, print) {
+  const [constant] = path.getValue().body;
+
+  let args = [concat(["*", path.call(print, "body", 1)])]
+    .concat(path.map(print, "body", 2))
+    .concat(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 = [];
 
-  if (keyValuePairs) {
+  if (keyValuePairs.length > 0) {
     const printPair = (pairPath) => {
       const parts = [pairPath.call(print, 0)];
 
@@ -80,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) {
@@ -96,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)]))
   ];
@@ -111,8 +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
 };

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([

data/src/ruby/nodes/return.js

@@ -0,0 +1,94 @@
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  line,
+  join,
+  softline
+} = require("../../prettier");
+const { literal } = require("../../utils");
+
+// You can't skip the parentheses if you have comments or certain operators with
+// lower precedence than the return keyword.
+const canSkipParens = (args) => {
+  const stmts = args.body[0].body[0];
+
+  // return(
+  //   # a
+  //   b
+  // )
+  if (stmts.comments) {
+    return false;
+  }
+
+  const stmt = stmts.body[0];
+
+  // return (a or b)
+  if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+    return false;
+  }
+
+  // return (not a)
+  if (stmt.type === "unary" && stmt.oper === "not") {
+    return false;
+  }
+
+  return true;
+};
+
+const printReturn = (path, opts, print) => {
+  let args = path.getValue().body[0].body[0];
+  let steps = ["body", 0, "body", 0];
+
+  if (args.body.length === 1) {
+    // If the body of the return contains parens, then just skip directly to the
+    // content of the parens so that we can skip printing parens if we don't
+    // want them.
+    if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
+      args = args.body[0].body[0];
+      steps = steps.concat("body", 0, "body", 0);
+    }
+
+    // If we're returning an array literal that isn't a special array, single
+    // element array, or an empty array, then we want to grab the arguments so
+    // that we can print them out as if they were normal return arguments.
+    if (
+      args.body[0] &&
+      args.body[0].type === "array" &&
+      args.body[0].body[0] &&
+      args.body[0].body[0].body.length > 1 &&
+      ["args", "args_add_star"].includes(args.body[0].body[0].type)
+    ) {
+      steps = steps.concat("body", 0, "body", 0);
+    }
+  }
+
+  // Now that we've established which actual node is the arguments to return,
+  // we grab it out of the path by diving down the steps that we've set up.
+  const parts = path.call.apply(path, [print].concat(steps));
+
+  // If we got the value straight out of the parens, then `parts` would only
+  // be a singular doc as opposed to an array.
+  const value = Array.isArray(parts) ? join(concat([",", line]), parts) : parts;
+
+  // We only get here if we have comments somewhere that would prevent us from
+  // skipping the parentheses.
+  if (args.body.length === 1 && args.body[0].type === "paren") {
+    return concat(["return", value]);
+  }
+
+  return group(
+    concat([
+      "return",
+      ifBreak(parts.length > 1 ? " [" : "(", " "),
+      indent(concat([softline, value])),
+      concat([softline, ifBreak(parts.length > 1 ? "]" : ")", "")])
+    ])
+  );
+};
+
+module.exports = {
+  return: printReturn,
+  return0: literal("return")
+};

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

@@ -10,7 +10,7 @@ const {
   literalline,
   softline,
   trim
-} = require("../prettier");
+} = require("../../prettier");
 
 function printBodyStmt(path, opts, print) {
   const [stmts, rescue, elseClause, ensure] = path.getValue().body;
@@ -30,6 +30,7 @@ function printBodyStmt(path, opts, print) {
 
   if (elseClause) {
     // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+    /* istanbul ignore next */
     const stmts =
       elseClause.type === "else"
         ? path.call(print, "body", 2, "body", 0)
@@ -69,11 +70,7 @@ function printParen(path, opts, print) {
   }
 
   return group(
-    concat([
-      "(",
-      indent(concat([softline, contentDoc])),
-      concat([softline, ")"])
-    ])
+    concat(["(", indent(concat([softline, contentDoc])), softline, ")"])
   );
 }
 
@@ -123,12 +120,12 @@ module.exports = {
       if (lineNo === null) {
         parts.push(printed);
       } else if (
-        stmt.start - lineNo > 1 ||
+        stmt.sl - lineNo > 1 ||
         [stmt.type, stmts[index - 1].type].includes("access_ctrl")
       ) {
         parts.push(hardline, hardline, printed);
       } else if (
-        stmt.start !== lineNo ||
+        stmt.sl !== lineNo ||
         path.getParentNode().type !== "string_embexpr"
       ) {
         parts.push(hardline, printed);
@@ -136,7 +133,7 @@ module.exports = {
         parts.push("; ", printed);
       }
 
-      lineNo = stmt.end;
+      lineNo = stmt.el;
     });
 
     return concat(parts);

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

@@ -6,7 +6,7 @@ const {
   literalline,
   softline,
   join
-} = require("../prettier");
+} = require("../../prettier");
 
 // If there is some part of this string that matches an escape sequence or that
 // contains the interpolation pattern ("#{"), then we are locked into whichever
@@ -31,17 +31,10 @@ function isSingleQuotable(node) {
 
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
-function normalizeQuotes(content, enclosingQuote, originalQuote) {
-  const replaceOther = originalQuote === '"';
-  const otherQuote = enclosingQuote === '"' ? "'" : '"';
-
+function normalizeQuotes(content, enclosingQuote) {
   // Escape and unescape single and double quotes as needed to be able to
   // enclose `content` with `enclosingQuote`.
   return content.replace(quotePattern, (match, escaped, quote) => {
-    if (replaceOther && escaped === otherQuote) {
-      return escaped;
-    }
-
     if (quote === enclosingQuote) {
       return `\\${quote}`;
     }
@@ -97,12 +90,34 @@ function printDynaSymbol(path, opts, print) {
   return concat([":", quote].concat(path.map(print, "body")).concat(quote));
 }
 
+function printStringConcat(path, opts, print) {
+  const [leftDoc, rightDoc] = path.map(print, "body");
+
+  return group(concat([leftDoc, " \\", indent(concat([hardline, rightDoc]))]));
+}
+
 // Prints out an interpolated variable in the string by converting it into an
 // embedded expression.
 function printStringDVar(path, opts, print) {
   return concat(["#{", path.call(print, "body", 0), "}"]);
 }
 
+function printStringEmbExpr(path, opts, print) {
+  const parts = path.call(print, "body", 0);
+
+  // If the interpolated expression is inside of a heredoc or an xstring
+  // literal (a string that gets sent to the command line) then we don't want
+  // to automatically indent, as this can lead to some very odd looking
+  // expressions
+  if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
+    return concat(["#{", parts, "}"]);
+  }
+
+  return group(
+    concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
+  );
+}
+
 // Prints out a literal string. This function does its best to respect the
 // wishes of the user with regards to single versus double quotes, but if the
 // string contains any escape expressions then it will just keep the original
@@ -131,10 +146,7 @@ function printStringLiteral(path, { rubySingleQuote }, print) {
     }
 
     // In this case, the part of the string is just regular string content
-    return join(
-      literalline,
-      normalizeQuotes(part.body, quote, node.quote).split("\n")
-    );
+    return join(literalline, normalizeQuotes(part.body, quote).split("\n"));
   });
 
   return concat([quote].concat(parts).concat(getClosingQuote(quote)));
@@ -155,30 +167,9 @@ function printXStringLiteral(path, opts, print) {
 module.exports = {
   "@CHAR": printChar,
   dyna_symbol: printDynaSymbol,
-  string_concat: (path, opts, print) =>
-    group(
-      concat([
-        path.call(print, "body", 0),
-        " \\",
-        indent(concat([hardline, path.call(print, "body", 1)]))
-      ])
-    ),
+  string_concat: printStringConcat,
   string_dvar: printStringDVar,
-  string_embexpr: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    // If the interpolated expression is inside of a heredoc or an xstring
-    // literal (a string that gets sent to the command line) then we don't want
-    // to automatically indent, as this can lead to some very odd looking
-    // expressions
-    if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
-      return concat(["#{", parts, "}"]);
-    }
-
-    return group(
-      concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
-    );
-  },
+  string_embexpr: printStringEmbExpr,
   string_literal: printStringLiteral,
   symbol_literal: printSymbolLiteral,
   xstring_literal: printXStringLiteral