prettier 1.0.1 → 1.2.3

data/src/nodes/loops.js

@@ -1,101 +0,0 @@
-const {
-  align,
-  breakParent,
-  concat,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  softline
-} = require("../prettier");
-
-const { containsAssignment } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
-
-const printLoop = (keyword, modifier) => (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));
-};
-
-// Technically this is incorrect. A `for` loop actually introduces and modifies
-// a local variable that then remains in the outer scope. Additionally, if the
-// `each` method was somehow missing from the enumerable (it's possible...),
-// then this transformation would fail. However - I've never actually seen a
-// `for` loop used in production. If someone actually calls me on it, I'll fix
-// this, but for now I'm leaving it.
-const printFor = (path, opts, print) =>
-  group(
-    concat([
-      path.call(print, "body", 1),
-      ".each do |",
-      path.call(print, "body", 0),
-      "|",
-      indent(concat([hardline, path.call(print, "body", 2)])),
-      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/regexp.js

@@ -1,49 +0,0 @@
-const { concat } = require("../prettier");
-const { hasAncestor } = require("../utils");
-
-function isStringContent(node) {
-  return node.type === "@tstring_content";
-}
-
-function shouldUseBraces(path) {
-  const node = path.getValue();
-  const first = node.body[0];
-
-  // If the first part of this regex is plain string content and we have a
-  // space or an =, then we want to use braces because otherwise we could end up
-  // with an ambiguous operator, e.g. foo / bar/ or foo /=bar/
-  if (
-    first &&
-    isStringContent(first) &&
-    [" ", "="].includes(first.body[0]) &&
-    hasAncestor(path, ["command", "command_call"])
-  ) {
-    return true;
-  }
-
-  return node.body.some(
-    (child) => isStringContent(child) && child.body.includes("/")
-  );
-}
-
-// 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 useBraces = shouldUseBraces(path);
-
-  const parts = [useBraces ? "%r{" : "/"]
-    .concat(path.map(print, "body"))
-    .concat([useBraces ? "}" : "/", node.ending.slice(1)]);
-
-  return concat(parts);
-}
-
-module.exports = {
-  regexp_literal: printRegexpLiteral
-};

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")
-};