prettier 1.5.5 → 2.0.0.pre.rc2

data/src/ruby/nodes/conditionals.js

@@ -1,280 +0,0 @@
-const {
-  align,
-  breakParent,
-  concat,
-  hardline,
-  group,
-  ifBreak,
-  indent,
-  softline
-} = require("../../prettier");
-
-const { containsAssignment, isEmptyStmts } = require("../../utils");
-const inlineEnsureParens = require("../../utils/inlineEnsureParens");
-
-const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
-  concat([
-    `${keyword} `,
-    align(keyword.length + 1, path.call(print, "body", 0)),
-    indent(concat([softline, path.call(print, "body", 1)])),
-    concat([softline, path.call(print, "body", 2)]),
-    concat([softline, "end"]),
-    breaking ? breakParent : ""
-  ]);
-
-// For the unary `not` operator, we need to explicitly add parentheses to it in
-// order for it to be valid from within a ternary. Otherwise if the clause of
-// the ternary isn't a unary `not`, we can just pass it along.
-const printTernaryClause = (clause) => {
-  if (clause.type === "concat") {
-    const [part] = clause.parts;
-
-    if (part.type === "concat" && part.parts[0] === "not") {
-      // We are inside of a statements list and the statement is a unary `not`.
-      return concat(["not(", part.parts[2], ")"]);
-    }
-
-    if (clause.parts[0] === "not") {
-      // We are inside a ternary condition and the clause is a unary `not`.
-      return concat(["not(", clause.parts[2], ")"]);
-    }
-  }
-
-  return clause;
-};
-
-// The conditions for a ternary look like `foo : bar` where `foo` represents
-// the truthy clause and `bar` represents the falsy clause. In the case that the
-// parent node is an `unless`, these have to flip in order.
-const printTernaryClauses = (keyword, truthyClause, falsyClause) => {
-  const parts = [
-    printTernaryClause(truthyClause),
-    " : ",
-    printTernaryClause(falsyClause)
-  ];
-
-  return keyword === "if" ? parts : parts.reverse();
-};
-
-// Handles ternary nodes. If it does not fit on one line, then we break out into
-// an if/else statement. Otherwise we remain as a ternary.
-const printTernary = (path, _opts, print) => {
-  const [predicate, truthyClause, falsyClause] = path.map(print, "body");
-  const ternaryClauses = printTernaryClauses("if", truthyClause, falsyClause);
-
-  return group(
-    ifBreak(
-      concat([
-        "if ",
-        align(3, predicate),
-        indent(concat([softline, truthyClause])),
-        concat([softline, "else"]),
-        indent(concat([softline, falsyClause])),
-        concat([softline, "end"])
-      ]),
-      concat([predicate, " ? "].concat(ternaryClauses))
-    )
-  );
-};
-
-// Prints an `if_mod` or `unless_mod` node. Because it was previously in the
-// modifier form, we're guaranteed to not have an additional node, so we can
-// just work with the predicate and the body.
-function printSingle(keyword, modifier = false) {
-  return function printSingleWithKeyword(path, { rubyModifier }, print) {
-    const [_predicateNode, statementsNode] = path.getValue().body;
-    const predicateDoc = path.call(print, "body", 0);
-    const statementsDoc = path.call(print, "body", 1);
-
-    const multilineParts = [
-      `${keyword} `,
-      align(keyword.length + 1, predicateDoc),
-      indent(concat([softline, statementsDoc])),
-      softline,
-      "end"
-    ];
-
-    // If we do not allow modifier form conditionals or there are comments
-    // inside of the body of the conditional, then we must print in the
-    // multiline form.
-    if (!rubyModifier || (!modifier && statementsNode.body[0].comments)) {
-      return concat([concat(multilineParts), breakParent]);
-    }
-
-    const inline = concat(
-      inlineEnsureParens(path, [
-        path.call(print, "body", 1),
-        ` ${keyword} `,
-        path.call(print, "body", 0)
-      ])
-    );
-
-    // An expression with a conditional modifier (expression if true), the
-    // conditional body is parsed before the predicate expression, meaning that
-    // if the parser encountered a variable declaration, it would initialize
-    // that variable first before evaluating the predicate expression. That
-    // parse order means the difference between a NameError or not. #591
-    // https://docs.ruby-lang.org/en/2.0.0/syntax/control_expressions_rdoc.html#label-Modifier+if+and+unless
-    if (modifier && containsAssignment(statementsNode)) {
-      return inline;
-    }
-
-    return group(ifBreak(concat(multilineParts), inline));
-  };
-}
-
-const noTernary = [
-  "alias",
-  "assign",
-  "break",
-  "command",
-  "command_call",
-  "if_mod",
-  "ifop",
-  "lambda",
-  "massign",
-  "next",
-  "opassign",
-  "rescue_mod",
-  "return",
-  "return0",
-  "super",
-  "undef",
-  "unless_mod",
-  "until_mod",
-  "var_alias",
-  "void_stmt",
-  "while_mod",
-  "yield",
-  "yield0",
-  "zsuper"
-];
-
-// Certain expressions cannot be reduced to a ternary without adding parens
-// around them. In this case we say they cannot be ternaried and default instead
-// to breaking them into multiple lines.
-const canTernaryStmts = (stmts) => {
-  if (stmts.body.length !== 1) {
-    return false;
-  }
-
-  const stmt = stmts.body[0];
-
-  // If the user is using one of the lower precedence "and" or "or" operators,
-  // then we can't use a ternary expression as it would break the flow control.
-  if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
-    return false;
-  }
-
-  // Check against the blocklist of statement types that are not allowed to be
-  // a part of a ternary expression.
-  return !noTernary.includes(stmt.type);
-};
-
-// In order for an `if` or `unless` expression to be shortened to a ternary,
-// there has to be one and only one "addition" (another clause attached) which
-// is of the "else" type. Both the body of the main node and the body of the
-// additional node must have only one statement, and that statement list must
-// pass the `canTernaryStmts` check.
-const canTernary = (path) => {
-  const [predicate, stmts, addition] = path.getValue().body;
-
-  return (
-    !["assign", "opassign", "command_call", "command"].includes(
-      predicate.type
-    ) &&
-    addition &&
-    addition.type === "else" &&
-    [stmts, addition.body[0]].every(canTernaryStmts)
-  );
-};
-
-// A normalized print function for both `if` and `unless` nodes.
-const printConditional = (keyword) => (path, { rubyModifier }, print) => {
-  if (canTernary(path)) {
-    let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
-      printTernaryClauses(
-        keyword,
-        path.call(print, "body", 1),
-        path.call(print, "body", 2, "body", 0)
-      )
-    );
-
-    if (["binary", "call"].includes(path.getParentNode().type)) {
-      ternaryParts = ["("].concat(ternaryParts).concat(")");
-    }
-
-    return group(
-      ifBreak(printWithAddition(keyword, path, print), concat(ternaryParts))
-    );
-  }
-
-  const [predicate, statements, addition] = path.getValue().body;
-
-  // If there's an additional clause that wasn't matched earlier, we know we
-  // can't go for the inline option.
-  if (addition) {
-    return group(printWithAddition(keyword, path, print, { breaking: true }));
-  }
-
-  // If the body of the conditional is empty, then we explicitly have to use the
-  // block form.
-  if (isEmptyStmts(statements)) {
-    return concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0)),
-      concat([hardline, "end"])
-    ]);
-  }
-
-  // If the predicate of the conditional contains an assignment, then we can't
-  // know for sure that it doesn't impact the body of the conditional, so we
-  // have to default to the block form.
-  if (containsAssignment(predicate)) {
-    return concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0)),
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      concat([hardline, "end"])
-    ]);
-  }
-
-  return printSingle(keyword)(path, { rubyModifier }, print);
-};
-
-module.exports = {
-  else: (path, opts, print) => {
-    const stmts = path.getValue().body[0];
-
-    return concat([
-      stmts.body.length === 1 && stmts.body[0].type === "command"
-        ? breakParent
-        : "",
-      "else",
-      indent(concat([softline, path.call(print, "body", 0)]))
-    ]);
-  },
-  elsif: (path, opts, print) => {
-    const [_predicate, _statements, addition] = path.getValue().body;
-    const parts = [
-      group(
-        concat([
-          "elsif ",
-          align("elsif".length - 1, path.call(print, "body", 0))
-        ])
-      ),
-      indent(concat([hardline, path.call(print, "body", 1)]))
-    ];
-
-    if (addition) {
-      parts.push(group(concat([hardline, path.call(print, "body", 2)])));
-    }
-
-    return group(concat(parts));
-  },
-  if: printConditional("if"),
-  ifop: printTernary,
-  if_mod: printSingle("if", true),
-  unless: printConditional("unless"),
-  unless_mod: printSingle("unless", true)
-};

data/src/ruby/nodes/constants.js

@@ -1,43 +0,0 @@
-const { concat, group, indent, join, softline } = require("../../prettier");
-const { makeCall } = require("../../utils");
-
-function printConstPath(path, opts, print) {
-  return join("::", path.map(print, "body"));
-}
-
-function printConstRef(path, opts, print) {
-  return path.call(print, "body", 0);
-}
-
-function printDefined(path, opts, print) {
-  return group(
-    concat([
-      "defined?(",
-      indent(concat([softline, path.call(print, "body", 0)])),
-      concat([softline, ")"])
-    ])
-  );
-}
-
-function printField(path, opts, print) {
-  return group(
-    concat([
-      path.call(print, "body", 0),
-      concat([makeCall(path, opts, print), path.call(print, "body", 2)])
-    ])
-  );
-}
-
-function printTopConst(path, opts, print) {
-  return concat(["::", path.call(print, "body", 0)]);
-}
-
-module.exports = {
-  const_path_field: printConstPath,
-  const_path_ref: printConstPath,
-  const_ref: printConstRef,
-  defined: printDefined,
-  field: printField,
-  top_const_field: printTopConst,
-  top_const_ref: printTopConst
-};

data/src/ruby/nodes/flow.js

@@ -1,74 +0,0 @@
-const { concat, join } = require("../../prettier");
-const { literal } = require("../../utils");
-
-const nodeDive = (node, steps) => {
-  let current = node;
-
-  steps.forEach((step) => {
-    current = current[step];
-  });
-
-  return current;
-};
-
-const unskippableParens = [
-  "if_mod",
-  "rescue_mod",
-  "unless_mod",
-  "until_mod",
-  "while_mod"
-];
-
-const maybeHandleParens = (path, print, keyword, steps) => {
-  const node = nodeDive(path.getValue(), steps);
-  if (node.type !== "paren") {
-    return null;
-  }
-
-  const stmts = node.body[0].body;
-  if (stmts.length === 1 && !unskippableParens.includes(stmts[0].type)) {
-    return concat([
-      `${keyword} `,
-      path.call.apply(path, [print].concat(steps).concat("body", 0))
-    ]);
-  }
-
-  return concat([keyword, path.call.apply(path, [print].concat(steps))]);
-};
-
-module.exports = {
-  break: (path, opts, print) => {
-    const content = path.getValue().body[0];
-
-    if (content.body.length === 0) {
-      return "break";
-    }
-
-    const steps = ["body", 0, "body", 0, "body", 0];
-    return (
-      maybeHandleParens(path, print, "break", steps) ||
-      concat(["break ", join(", ", path.call(print, "body", 0))])
-    );
-  },
-  next: (path, opts, print) => {
-    const args = path.getValue().body[0].body[0];
-
-    if (!args) {
-      return "next";
-    }
-
-    const steps = ["body", 0, "body", 0, "body", 0];
-    return (
-      maybeHandleParens(path, print, "next", steps) ||
-      concat(["next ", join(", ", path.call(print, "body", 0))])
-    );
-  },
-  yield: (path, opts, print) => {
-    if (path.getValue().body[0].type === "paren") {
-      return concat(["yield", path.call(print, "body", 0)]);
-    }
-
-    return concat(["yield ", join(", ", path.call(print, "body", 0))]);
-  },
-  yield0: literal("yield")
-};

data/src/ruby/nodes/hashes.js

@@ -1,164 +0,0 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  line
-} = require("../../prettier");
-
-const {
-  getTrailingComma,
-  printEmptyCollection,
-  skipAssignIndent
-} = 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
-// have to match keyword arguments to methods, but don't specify what that is.
-// After some experimentation, it looks like it's:
-//
-// * Starts with a letter (either case) or an underscore
-// * Does not end in equal
-//
-// This function represents that check, as it determines if it can convert the
-// symbol node into a hash label.
-function isValidHashLabel(symbolLiteral) {
-  const label = symbolLiteral.body[0].body;
-  return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
-}
-
-function canUseHashLabels(contentsNode) {
-  return contentsNode.body.every((assocNode) => {
-    if (assocNode.type === "assoc_splat") {
-      return true;
-    }
-
-    switch (assocNode.body[0].type) {
-      case "@label":
-        return true;
-      case "symbol_literal":
-        return isValidHashLabel(assocNode.body[0]);
-      case "dyna_symbol":
-        return true;
-      default:
-        return false;
-    }
-  });
-}
-
-function printHashKeyLabel(path, print) {
-  const node = path.getValue();
-
-  switch (node.type) {
-    case "@label":
-      return print(path);
-    case "symbol_literal":
-      return concat([path.call(print, "body", 0), ":"]);
-    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(":"));
-    }
-  }
-}
-
-function printHashKeyRocket(path, print) {
-  const node = path.getValue();
-  const doc = print(path);
-
-  if (node.type === "@label") {
-    return `:${doc.slice(0, doc.length - 1)} =>`;
-  }
-
-  return concat([doc, " =>"]);
-}
-
-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 we're printing a child hash then we want it to break along with its
-  // parent hash, so we don't group the parts.
-  if (valueNode.type === "hash") {
-    parts.push(" ", valueDoc);
-    return concat(parts);
-  }
-
-  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();
-
-  // First determine which key printer we're going to use, so that the child
-  // nodes can reference it when they go to get printed.
-  node.keyPrinter =
-    opts.rubyHashLabel && canUseHashLabels(path.getValue())
-      ? printHashKeyLabel
-      : printHashKeyRocket;
-
-  return join(concat([",", line]), path.map(print, "body"));
-}
-
-function printHash(path, opts, print) {
-  const hashNode = path.getValue();
-
-  // Hashes normally have a single assoclist_from_args child node. If it's
-  // missing, then it means we're dealing with an empty hash, so we can just
-  // exit here and print.
-  if (hashNode.body[0] === null) {
-    return printEmptyCollection(path, opts, "{", "}");
-  }
-
-  let hashDoc = concat([
-    "{",
-    indent(
-      concat([
-        line,
-        path.call(print, "body", 0),
-        getTrailingComma(opts) ? ifBreak(",", "") : ""
-      ])
-    ),
-    line,
-    "}"
-  ]);
-
-  // If we're inside another hash, then we don't want to group our contents
-  // because we want this hash to break along with its parent hash.
-  if (path.getParentNode().type === "assoc_new") {
-    return hashDoc;
-  }
-
-  return group(hashDoc);
-}
-
-module.exports = {
-  assoc_new: printAssocNew,
-  assoc_splat: printAssocSplat,
-  assoclist_from_args: printHashContents,
-  bare_assoc_hash: printHashContents,
-  hash: printHash
-};

data/src/ruby/nodes/heredocs.js

@@ -1,36 +0,0 @@
-const { concat, group, lineSuffix, join } = require("../../prettier");
-const { literallineWithoutBreakParent } = require("../../utils");
-
-function printHeredoc(path, opts, print) {
-  const { body, ending } = path.getValue();
-
-  const parts = body.map((part, index) => {
-    if (part.type !== "@tstring_content") {
-      // In this case, the part of the string is an embedded expression
-      return path.call(print, "body", index);
-    }
-
-    // In this case, the part of the string is just regular string content
-    return join(literallineWithoutBreakParent, part.body.split("\n"));
-  });
-
-  // We use a literalline break because matching indentation is required
-  // for the heredoc contents and ending. If the line suffix contains a
-  // break-parent, all ancestral groups are broken, and heredocs automatically
-  // break lines in groups they appear in. We prefer them to appear in-line if
-  // possible, so we use a literalline without the break-parent.
-  return group(
-    concat([
-      path.call(print, "beging"),
-      lineSuffix(
-        group(
-          concat([literallineWithoutBreakParent].concat(parts).concat(ending))
-        )
-      )
-    ])
-  );
-}
-
-module.exports = {
-  heredoc: printHeredoc
-};

data/src/ruby/nodes/hooks.js

@@ -1,34 +0,0 @@
-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/ruby/nodes/ints.js

@@ -1,31 +0,0 @@
-// An @int node is any literal integer in Ruby. They can come in a number of
-// bases, and look like the following:
-//
-// Binary (2)       - 0b0110
-// Octal (8)        - 0o34 or 034
-// Decimal (10)     - a normal number like 159
-// Hexidecimal (16) - 0xac5
-//
-// If it's a decimal number, it can be optional separated by any number of
-// arbitrarily places underscores. This can be useful for dollars and cents
-// (34_99), dates (2020_11_30), and normal 3 digit separation (1_222_333).
-function printInt(path, _opts, _print) {
-  const { body } = path.getValue();
-
-  // If the number is a base 10 number, is sufficiently large, and is not
-  // already formatted with underscores, then add them in in between the
-  // numbers every three characters starting from the right.
-  if (!body.startsWith("0") && body.length >= 5 && !body.includes("_")) {
-    return `  ${body}`
-      .slice((body.length + 2) % 3)
-      .match(/.{3}/g)
-      .join("_")
-      .trim();
-  }
-
-  return body;
-}
-
-module.exports = {
-  "@int": printInt
-};