prettier 1.0.1 → 1.2.3

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/{nodes → ruby/nodes}/hooks.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, line } = require("../prettier");
-const { isEmptyStmts } = require("../utils");
+const { concat, group, indent, line } = require("../../prettier");
+const { isEmptyStmts } = require("../../utils");
 
 // 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`

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/ruby/nodes/loops.js

@@ -0,0 +1,104 @@
+const {
+  align,
+  breakParent,
+  concat,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  join,
+  softline
+} = require("../../prettier");
+
+const { containsAssignment } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
+
+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"
+        ])
+      );
+    }
+
+    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;
+    }
+
+    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]);
+    }
+
+    return group(ifBreak(blockLoop, inlineLoop));
+  };
+}
+
+function printFor(path, opts, print) {
+  const [varDoc, rangeDoc, stmtsDoc] = path.map(print, "body");
+  const varsDoc =
+    path.getValue().body[0].type === "mlhs" ? join(", ", varDoc) : varDoc;
+
+  return group(
+    concat([
+      "for ",
+      varsDoc,
+      " in ",
+      rangeDoc,
+      indent(concat([hardline, stmtsDoc])),
+      concat([hardline, "end"])
+    ])
+  );
+}
+
+module.exports = {
+  while: printLoop("while", false),
+  while_mod: printLoop("while", true),
+  until: printLoop("until", false),
+  until_mod: printLoop("until", true),
+  for: printFor
+};

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 } = 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),
@@ -48,8 +46,38 @@ function printMethod(offset) {
   };
 }
 
+function printSingleLineMethod(path, opts, print) {
+  let paramsNode = path.getValue().body[1];
+  let paramsDoc = "";
+
+  if (paramsNode) {
+    if (paramsNode.body[0].type === "params") {
+      paramsNode = paramsNode.body[0];
+    }
+
+    if (paramsNode.type === "params" && paramsNode.body.some((type) => type)) {
+      paramsDoc = path.call(print, "body", 1);
+    }
+  }
+
+  return group(
+    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)
+  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) {

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

@@ -1,4 +1,13 @@
-const { concat, group, hardline, indent, join, line } = require("../prettier");
+const {
+  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 +43,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,6 +54,22 @@ 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 = [];
@@ -80,10 +102,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) {
@@ -111,8 +131,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/ruby/nodes/regexp.js

@@ -0,0 +1,56 @@
+const { concat } = require("../../prettier");
+const { hasAncestor } = require("../../utils");
+
+function hasContent(node, pattern) {
+  return node.body.some(
+    (child) => child.type === "@tstring_content" && pattern.test(child.body)
+  );
+}
+
+// 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 (
+    firstChildNode &&
+    firstChildNode.type === "@tstring_content" &&
+    [" ", "="].includes(firstChildNode.body[0]) &&
+    hasAncestor(path, ["command", "command_call"])
+  );
+}
+
+// This function is responsible for printing out regexp_literal nodes. They can
+// either use the special %r literal syntax or they can use forward slashes. At
+// the end of either of those they can have modifiers like m or x that have
+// special meaning for the regex engine.
+//
+// We favor the use of forward slashes unless the regex contains a forward slash
+// itself. In that case we switch over to using %r with braces.
+function printRegexpLiteral(path, opts, print) {
+  const node = path.getValue();
+  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, /\//);
+
+  // 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(
+    [useBraces ? "%r{" : "/"]
+      .concat(docs)
+      .concat(useBraces ? "}" : "/", node.ending.slice(1))
+  );
+}
+
+module.exports = {
+  regexp_literal: printRegexpLiteral
+};

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,98 @@
+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) {
+    return "return";
+  }
+
+  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")
+};