prettier 1.1.0 → 1.2.4

data/src/ruby/nodes/case.js

@@ -0,0 +1,65 @@
+const {
+  align,
+  concat,
+  fill,
+  group,
+  hardline,
+  indent,
+  line
+} = require("../../prettier");
+
+function printCase(path, opts, print) {
+  const statement = ["case"];
+
+  // You don't need to explicitly have something to test against in a case
+  // statement (without it it effectively becomes an if/elsif chain).
+  if (path.getValue().body[0]) {
+    statement.push(" ", path.call(print, "body", 0));
+  }
+
+  return concat(
+    statement.concat([hardline, path.call(print, "body", 1), hardline, "end"])
+  );
+}
+
+function printWhen(path, opts, print) {
+  const [_preds, _stmts, addition] = path.getValue().body;
+
+  // 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) => {
+      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);
+  const parts = [concat(["when ", align("when ".length, preds)])];
+
+  // It's possible in a when to just have empty void statements, in which case
+  // we would skip adding the body.
+  if (!stmts.parts.every((part) => !part)) {
+    parts.push(indent(concat([hardline, stmts])));
+  }
+
+  // This is the next clause on the case statement, either another `when` or
+  // an `else` clause.
+  if (addition) {
+    parts.push(hardline, path.call(print, "body", 2));
+  }
+
+  return group(concat(parts));
+}
+
+module.exports = {
+  case: printCase,
+  when: printWhen
+};

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

@@ -5,7 +5,7 @@ const {
   ifBreak,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printClass(path, opts, print) {
   const [_constant, superclass, bodystmt] = path.getValue().body;

data/src/ruby/nodes/commands.js

@@ -0,0 +1,126 @@
+const {
+  align,
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
+const { makeCall } = require("../../utils");
+
+function docLength(doc) {
+  if (doc.length) {
+    return doc.length;
+  }
+
+  if (doc.parts) {
+    return doc.parts.reduce((sum, child) => sum + docLength(child), 0);
+  }
+
+  if (doc.contents) {
+    return docLength(doc.contents);
+  }
+
+  return 0;
+}
+
+function hasDef(node) {
+  return (
+    node.body[1].type === "args_add_block" &&
+    node.body[1].body[0].type === "args" &&
+    node.body[1].body[0].body[0] &&
+    ["def", "defs"].includes(node.body[1].body[0].body[0].type)
+  );
+}
+
+// Very special handling case for rspec matchers. In general with rspec matchers
+// you expect to see something like:
+//
+//     expect(foo).to receive(:bar).with(
+//       'one',
+//       'two',
+//       'three',
+//       'four',
+//       'five'
+//     )
+//
+// In this case the arguments are aligned to the left side as opposed to being
+// aligned with the `receive` call.
+function skipArgsAlign(path) {
+  return ["to", "not_to"].includes(path.getValue().body[2].body);
+}
+
+// If there is a ternary argument to a command and it's going to get broken
+// into multiple lines, then we're going to have to use parentheses around the
+// command in order to make sure operator precedence doesn't get messed up.
+function hasTernaryArg(node) {
+  return node.body[0].body.some((child) => child.type === "ifop");
+}
+
+function printCommand(path, opts, print) {
+  const node = path.getValue();
+
+  const command = path.call(print, "body", 0);
+  const joinedArgs = join(concat([",", line]), path.call(print, "body", 1));
+
+  const hasTernary = hasTernaryArg(node.body[1]);
+  let breakArgs;
+
+  if (hasTernary) {
+    breakArgs = indent(concat([softline, joinedArgs]));
+  } else if (hasDef(path.getValue())) {
+    breakArgs = joinedArgs;
+  } else {
+    breakArgs = align(command.length + 1, joinedArgs);
+  }
+
+  return group(
+    ifBreak(
+      concat([
+        command,
+        hasTernary ? "(" : " ",
+        breakArgs,
+        hasTernary ? concat([softline, ")"]) : ""
+      ]),
+      concat([command, " ", joinedArgs])
+    )
+  );
+}
+
+function printCommandCall(path, opts, print) {
+  const node = path.getValue();
+  const parts = [
+    path.call(print, "body", 0),
+    makeCall(path, opts, print),
+    path.call(print, "body", 2)
+  ];
+
+  if (!node.body[3]) {
+    return concat(parts);
+  }
+
+  const argDocs = join(concat([",", line]), path.call(print, "body", 3));
+  let breakDoc;
+
+  if (hasTernaryArg(node.body[3])) {
+    parts.push("(");
+    breakDoc = parts.concat(indent(concat([softline, argDocs])), softline, ")");
+  } else if (skipArgsAlign(path)) {
+    parts.push(" ");
+    breakDoc = parts.concat(argDocs);
+  } else {
+    parts.push(" ");
+    breakDoc = parts.concat(align(docLength(concat(parts)), argDocs));
+  }
+
+  const joinedDoc = parts.concat(argDocs);
+
+  return group(ifBreak(concat(breakDoc), concat(joinedDoc)));
+}
+
+module.exports = {
+  command: printCommand,
+  command_call: printCommandCall
+};

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 } = 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,36 @@ function printMethod(offset) {
   };
 }
 
+function printSingleLineMethod(path, opts, print) {
+  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 ",
+      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
 };