prettier 1.2.0 → 1.2.5

data/src/nodes/case.js

@@ -1,61 +0,0 @@
-const {
-  align,
-  concat,
-  fill,
-  group,
-  hardline,
-  indent,
-  line
-} = require("../prettier");
-
-module.exports = {
-  case: (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"])
-    );
-  },
-  when: (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));
-  }
-};

data/src/nodes/commands.js

@@ -1,91 +0,0 @@
-const {
-  align,
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  line,
-  softline
-} = require("../prettier");
-const { docLength, makeCall } = require("../utils");
-
-const hasDef = (node) =>
-  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.
-const skipArgsAlign = (path) =>
-  ["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.
-const hasTernaryArg = (path) =>
-  path.getValue().body[1].body[0].body.some((node) => node.type === "ifop");
-
-module.exports = {
-  command: (path, opts, print) => {
-    const command = path.call(print, "body", 0);
-    const joinedArgs = join(concat([",", line]), path.call(print, "body", 1));
-
-    const hasTernary = hasTernaryArg(path);
-    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])
-      )
-    );
-  },
-  command_call: (path, opts, print) => {
-    const parts = [
-      path.call(print, "body", 0),
-      makeCall(path, opts, print),
-      path.call(print, "body", 2)
-    ];
-
-    if (!path.getValue().body[3]) {
-      return concat(parts);
-    }
-
-    parts.push(" ");
-
-    const joinedArgs = join(concat([",", line]), path.call(print, "body", 3));
-    const breakArgs = skipArgsAlign(path)
-      ? joinedArgs
-      : align(docLength(concat(parts)), joinedArgs);
-
-    return group(
-      ifBreak(concat(parts.concat(breakArgs)), concat(parts.concat(joinedArgs)))
-    );
-  }
-};

data/src/nodes/hooks.js

@@ -1,44 +0,0 @@
-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`
-// 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) {
-    const stmtsNode = path.getValue().body[1];
-    const printedStmts = path.call(print, "body", 1);
-
-    const parts = [
-      name,
-      " ",
-      path.call(print, "body", 0),
-      indent(concat([line, printedStmts])),
-      concat([line, "}"])
-    ];
-
-    // If there are no statements but there are comments, then we want to skip
-    // printing the newline so that we don't end up with multiple spaces.
-    if (isEmptyStmts(stmtsNode) && stmtsNode.comments) {
-      parts[1] = indent(printedStmts);
-    }
-
-    return group(concat(parts));
-  };
-}
-
-module.exports = {
-  BEGIN: printHook("BEGIN"),
-  END: printHook("END")
-};

data/src/nodes/return.js

@@ -1,72 +0,0 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  line,
-  join,
-  softline
-} = require("../prettier");
-const { literal } = require("../utils");
-
-// You can't skip the parentheses if you have the `and` or `or` operator,
-// because they have low enough operator precedence that you need to explicitly
-// keep them in there.
-const canSkipParens = (args) => {
-  const statement = args.body[0].body[0].body[0];
-  return (
-    statement.type !== "binary" || !["and", "or"].includes(statement.body[1])
-  );
-};
-
-const printReturn = (path, opts, print) => {
-  let args = path.getValue().body[0].body[0];
-  let steps = ["body", 0, "body", 0];
-
-  if (!args) {
-    return "return";
-  }
-
-  // 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;
-
-  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")
-};