prettier 1.6.1 → 2.0.0.pre.rc1

data/src/ruby/nodes/regexp.js

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

@@ -1,101 +0,0 @@
-const {
-  align,
-  concat,
-  group,
-  hardline,
-  indent,
-  join,
-  line
-} = require("../../prettier");
-const { literal } = require("../../utils");
-
-function printBegin(path, opts, print) {
-  return concat([
-    "begin",
-    indent(concat([hardline, concat(path.map(print, "body"))])),
-    hardline,
-    "end"
-  ]);
-}
-
-function printEnsure(path, opts, print) {
-  return concat([
-    path.call(print, "body", 0),
-    indent(concat([hardline, path.call(print, "body", 1)]))
-  ]);
-}
-
-function printRescue(path, opts, print) {
-  const parts = ["rescue"];
-
-  if (path.getValue().body[0]) {
-    parts.push(align("rescue ".length, path.call(print, "body", 0)));
-  } else {
-    // If you don't specify an error to rescue in a `begin/rescue` block, then
-    // implicitly you're rescuing from `StandardError`. In this case, we're
-    // just going to explicitly add it.
-    parts.push(" StandardError");
-  }
-
-  const bodystmt = path.call(print, "body", 1);
-
-  if (bodystmt.parts.length > 0) {
-    parts.push(indent(concat([hardline, bodystmt])));
-  }
-
-  // This is the next clause on the `begin` statement, either another
-  // `rescue`, and `ensure`, or an `else` clause.
-  if (path.getValue().body[2]) {
-    parts.push(concat([hardline, path.call(print, "body", 2)]));
-  }
-
-  return group(concat(parts));
-}
-
-// This is a container node that we're adding into the AST that isn't present in
-// Ripper solely so that we have a nice place to attach inline comments.
-function printRescueEx(path, opts, print) {
-  const [exception, variable] = path.getValue().body;
-  const parts = [];
-
-  if (exception) {
-    let exceptionDoc = path.call(print, "body", 0);
-
-    if (Array.isArray(exceptionDoc)) {
-      const joiner = concat([",", line]);
-      exceptionDoc = group(join(joiner, exceptionDoc));
-    }
-
-    parts.push(" ", exceptionDoc);
-  }
-
-  if (variable) {
-    parts.push(" => ", path.call(print, "body", 1));
-  }
-
-  return group(concat(parts));
-}
-
-function printRescueMod(path, opts, print) {
-  const [statementDoc, valueDoc] = path.map(print, "body");
-
-  return concat([
-    "begin",
-    indent(concat([hardline, statementDoc])),
-    hardline,
-    "rescue StandardError",
-    indent(concat([hardline, valueDoc])),
-    hardline,
-    "end"
-  ]);
-}
-
-module.exports = {
-  begin: printBegin,
-  ensure: printEnsure,
-  redo: literal("redo"),
-  rescue: printRescue,
-  rescue_ex: printRescueEx,
-  rescue_mod: printRescueMod,
-  retry: literal("retry")
-};

data/src/ruby/nodes/return.js

@@ -1,94 +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 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.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")
-};

data/src/ruby/nodes/statements.js

@@ -1,142 +0,0 @@
-const {
-  breakParent,
-  concat,
-  dedent,
-  group,
-  hardline,
-  indent,
-  join,
-  line,
-  literalline,
-  softline,
-  trim
-} = require("../../prettier");
-
-const { isEmptyStmts } = require("../../utils");
-
-function printBodyStmt(path, opts, print) {
-  const [stmts, rescue, elseClause, ensure] = path.getValue().body;
-  const parts = [];
-
-  if (!isEmptyStmts(stmts)) {
-    parts.push(path.call(print, "body", 0));
-  }
-
-  if (rescue) {
-    parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
-  }
-
-  if (elseClause) {
-    // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-    /* istanbul ignore next */
-    const stmts =
-      elseClause.type === "else"
-        ? path.call(print, "body", 2, "body", 0)
-        : path.call(print, "body", 2);
-
-    parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
-  }
-
-  if (ensure) {
-    parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
-  }
-
-  return group(concat(parts));
-}
-
-const argNodeTypes = ["args", "args_add_star", "args_add_block"];
-
-function printParen(path, opts, print) {
-  const contentNode = path.getValue().body[0];
-
-  if (!contentNode) {
-    return "()";
-  }
-
-  let contentDoc = path.call(print, "body", 0);
-
-  // If the content is params, we're going to let it handle its own parentheses
-  // so that it breaks nicely.
-  if (contentNode.type === "params") {
-    return contentDoc;
-  }
-
-  // If we have an arg type node as the contents, then it's going to return an
-  // array, so we need to explicitly join that content here.
-  if (argNodeTypes.includes(contentNode.type)) {
-    contentDoc = join(concat([",", line]), contentDoc);
-  }
-
-  return group(
-    concat(["(", indent(concat([softline, contentDoc])), softline, ")"])
-  );
-}
-
-module.exports = {
-  "@__end__": (path, _opts, _print) => {
-    const { body } = path.getValue();
-    return concat([trim, "__END__", literalline, body]);
-  },
-  "@comment"(path, opts, _print) {
-    return opts.printer.printComment(path);
-  },
-  bodystmt: printBodyStmt,
-  paren: printParen,
-  program: (path, opts, print) =>
-    concat([join(hardline, path.map(print, "body")), hardline]),
-  stmts: (path, opts, print) => {
-    const stmts = path.getValue().body;
-
-    // This is a special case where we have only comments inside a statement
-    // list. In this case we want to avoid doing any kind of line number
-    // tracking and just print out the comments.
-    if (
-      stmts.length === 1 &&
-      stmts[0].type === "void_stmt" &&
-      stmts[0].comments
-    ) {
-      const comments = path.map(
-        (commentPath) => {
-          commentPath.getValue().printed = true;
-          return opts.printer.printComment(commentPath);
-        },
-        "body",
-        0,
-        "comments"
-      );
-
-      return concat([breakParent, join(hardline, comments)]);
-    }
-
-    const parts = [];
-    let lineNo = null;
-
-    stmts.forEach((stmt, index) => {
-      if (stmt.type === "void_stmt") {
-        return;
-      }
-
-      const printed = path.call(print, "body", index);
-
-      if (lineNo === null) {
-        parts.push(printed);
-      } else if (
-        stmt.sl - lineNo > 1 ||
-        [stmt.type, stmts[index - 1].type].includes("access_ctrl")
-      ) {
-        parts.push(hardline, hardline, printed);
-      } else if (
-        stmt.sl !== lineNo ||
-        path.getParentNode().type !== "string_embexpr"
-      ) {
-        parts.push(hardline, printed);
-      } else {
-        parts.push("; ", printed);
-      }
-
-      lineNo = stmt.el;
-    });
-
-    return concat(parts);
-  }
-};

data/src/ruby/nodes/strings.js

@@ -1,272 +0,0 @@
-const {
-  concat,
-  group,
-  hardline,
-  indent,
-  literalline,
-  removeLines,
-  softline,
-  join
-} = require("../../prettier");
-
-// If there is some part of this string that matches an escape sequence or that
-// contains the interpolation pattern ("#{"), then we are locked into whichever
-// quote the user chose. (If they chose single quotes, then double quoting
-// would activate the escape sequence, and if they chose double quotes, then
-// single quotes would deactivate it.)
-function isQuoteLocked(node) {
-  return node.body.some(
-    (part) =>
-      part.type === "@tstring_content" &&
-      (part.body.includes("#{") || part.body.includes("\\"))
-  );
-}
-
-// A string is considered to be able to use single quotes if it contains only
-// plain string content and that content does not contain a single quote.
-function isSingleQuotable(node) {
-  return node.body.every(
-    (part) => part.type === "@tstring_content" && !part.body.includes("'")
-  );
-}
-
-const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
-
-function normalizeQuotes(content, enclosingQuote) {
-  // Escape and unescape single and double quotes as needed to be able to
-  // enclose `content` with `enclosingQuote`.
-  return content.replace(quotePattern, (match, escaped, quote) => {
-    if (quote === enclosingQuote) {
-      return `\\${quote}`;
-    }
-
-    if (quote) {
-      return quote;
-    }
-
-    return `\\${escaped}`;
-  });
-}
-
-const quotePairs = {
-  "(": ")",
-  "[": "]",
-  "{": "}",
-  "<": ">"
-};
-
-function getClosingQuote(quote) {
-  if (!quote.startsWith("%")) {
-    return quote;
-  }
-
-  const boundary = /%[Qq]?(.)/.exec(quote)[1];
-  if (boundary in quotePairs) {
-    return quotePairs[boundary];
-  }
-
-  return boundary;
-}
-
-// Prints a @CHAR node. @CHAR nodes are special character strings that usually
-// are strings of length 1. If they're any longer than we'll try to apply the
-// correct quotes.
-function printChar(path, { rubySingleQuote }, _print) {
-  const { body } = path.getValue();
-
-  if (body.length !== 2) {
-    return body;
-  }
-
-  const quote = rubySingleQuote ? "'" : '"';
-  return concat([quote, body.slice(1), quote]);
-}
-
-function printPercentSDynaSymbol(path, opts, print) {
-  const node = path.getValue();
-  const parts = [];
-
-  // Push on the quote, which includes the opening character.
-  parts.push(node.quote);
-
-  path.each((childPath) => {
-    const childNode = childPath.getValue();
-
-    if (childNode.type !== "@tstring_content") {
-      // Here we are printing an embedded variable or expression.
-      parts.push(print(childPath));
-    } else {
-      // Here we are printing plain string content.
-      parts.push(join(literalline, childNode.body.split("\n")));
-    }
-  }, "body");
-
-  // Push on the closing character, which is the opposite of the third
-  // character from the opening.
-  parts.push(quotePairs[node.quote[2]]);
-
-  return concat(parts);
-}
-
-// We don't actually want to print %s symbols, as they're much more rarely seen
-// in the wild. But we're going to be forced into it if it's a multi-line symbol
-// or if the quoting would get super complicated.
-function shouldPrintPercentSDynaSymbol(node) {
-  // We shouldn't print a %s dyna symbol if it was not already that way in the
-  // original source.
-  if (node.quote[0] !== "%") {
-    return false;
-  }
-
-  // Here we're going to check if there is a closing character, a new line, or a
-  // quote in the content of the dyna symbol. If there is, then quoting could
-  // get weird, so just bail out and stick to the original bounds in the source.
-  const closing = quotePairs[node.quote[2]];
-
-  return node.body.some(
-    (child) =>
-      child.type === "@tstring_content" &&
-      (child.body.includes("\n") ||
-        child.body.includes(closing) ||
-        child.body.includes("'") ||
-        child.body.includes('"'))
-  );
-}
-
-// Prints a dynamic symbol. Assumes there's a quote property attached to the
-// node that will tell us which quote to use when printing. We're just going to
-// use whatever quote was provided.
-//
-// In the case of a plain dyna symbol, node.quote will be either :" or :'
-// For %s dyna symbols, node.quote will be %s[, %s(, %s{, or %s<
-function printDynaSymbol(path, opts, print) {
-  const node = path.getValue();
-
-  if (shouldPrintPercentSDynaSymbol(node)) {
-    return printPercentSDynaSymbol(path, opts, print);
-  }
-
-  const parts = [];
-  let quote;
-
-  if (isQuoteLocked(node)) {
-    if (node.quote.startsWith("%")) {
-      quote = opts.rubySingleQuote ? "'" : '"';
-    } else if (node.quote.startsWith(":")) {
-      quote = node.quote.slice(1);
-    } else {
-      quote = node.quote;
-    }
-  } else {
-    quote = opts.rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
-  }
-
-  parts.push(quote);
-  path.each((childPath) => {
-    const child = childPath.getValue();
-
-    if (child.type !== "@tstring_content") {
-      parts.push(print(childPath));
-    } else {
-      parts.push(
-        join(literalline, normalizeQuotes(child.body, quote).split("\n"))
-      );
-    }
-  }, "body");
-
-  parts.push(quote);
-
-  // If we're inside of an assoc_new node as the key, then it will handle
-  // printing the : on its own since it could change sides.
-  const parentNode = path.getParentNode();
-  if (parentNode.type !== "assoc_new" || parentNode.body[0] !== node) {
-    parts.unshift(":");
-  }
-
-  return concat(parts);
-}
-
-function printStringConcat(path, opts, print) {
-  const [leftDoc, rightDoc] = path.map(print, "body");
-
-  return group(concat([leftDoc, " \\", indent(concat([hardline, rightDoc]))]));
-}
-
-// Prints out an interpolated variable in the string by converting it into an
-// embedded expression.
-function printStringDVar(path, opts, print) {
-  return concat(["#{", path.call(print, "body", 0), "}"]);
-}
-
-function printStringEmbExpr(path, opts, print) {
-  const node = path.getValue();
-  const parts = path.call(print, "body", 0);
-
-  // If the contents of this embedded expression were originally on the same
-  // line in the source, then we're going to leave them in place and assume
-  // that's the way the developer wanted this expression represented.
-  if (node.sl === node.el) {
-    return concat(["#{", removeLines(parts), "}"]);
-  }
-
-  return group(
-    concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
-  );
-}
-
-// Prints out a literal string. This function does its best to respect the
-// wishes of the user with regards to single versus double quotes, but if the
-// string contains any escape expressions then it will just keep the original
-// quotes.
-function printStringLiteral(path, { rubySingleQuote }, print) {
-  const node = path.getValue();
-
-  // If the string is empty, it will not have any parts, so just print out the
-  // quotes corresponding to the config
-  if (node.body.length === 0) {
-    return rubySingleQuote ? "''" : '""';
-  }
-
-  // Determine the quote that should enclose the new string
-  let quote;
-  if (isQuoteLocked(node)) {
-    quote = node.quote;
-  } else {
-    quote = rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
-  }
-
-  const parts = node.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(literalline, normalizeQuotes(part.body, quote).split("\n"));
-  });
-
-  return concat([quote].concat(parts).concat(getClosingQuote(quote)));
-}
-
-// Prints out a symbol literal. Its child will always be the ident that
-// represents the string content of the symbol.
-function printSymbolLiteral(path, opts, print) {
-  return concat([":", path.call(print, "body", 0)]);
-}
-
-// Prints out an xstring literal. Its child is an array of string parts,
-// including plain string content and interpolated content.
-function printXStringLiteral(path, opts, print) {
-  return concat(["`"].concat(path.map(print, "body")).concat("`"));
-}
-
-module.exports = {
-  "@CHAR": printChar,
-  dyna_symbol: printDynaSymbol,
-  string_concat: printStringConcat,
-  string_dvar: printStringDVar,
-  string_embexpr: printStringEmbExpr,
-  string_literal: printStringLiteral,
-  symbol_literal: printSymbolLiteral,
-  xstring_literal: printXStringLiteral
-};

data/src/ruby/nodes/super.js

@@ -1,35 +0,0 @@
-const { align, concat, group, join, line } = require("../../prettier");
-const { literal } = require("../../utils");
-
-function printSuper(path, opts, print) {
-  const args = path.getValue().body[0];
-
-  if (args.type === "arg_paren") {
-    // In case there are explicitly no arguments but they are using parens,
-    // we assume they are attempting to override the initializer and pass no
-    // arguments up.
-    if (args.body[0] === null) {
-      return "super()";
-    }
-
-    return concat(["super", path.call(print, "body", 0)]);
-  }
-
-  const keyword = "super ";
-  const argsDocs = path.call(print, "body", 0);
-
-  return group(
-    concat([
-      keyword,
-      align(keyword.length, group(join(concat([",", line]), argsDocs)))
-    ])
-  );
-}
-
-// Version of super without any parens or args.
-const printZSuper = literal("super");
-
-module.exports = {
-  super: printSuper,
-  zsuper: printZSuper
-};