prettier 1.6.1 → 2.0.0.pre.rc1

data/src/ruby/nodes/blocks.js

@@ -1,90 +0,0 @@
-const {
-  breakParent,
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  removeLines,
-  softline
-} = require("../../prettier");
-const { hasAncestor } = require("../../utils");
-
-function printBlockVar(path, opts, print) {
-  const parts = ["|", removeLines(path.call(print, "body", 0))];
-
-  // The second part of this node is a list of optional block-local variables
-  if (path.getValue().body[1]) {
-    parts.push("; ", join(", ", path.map(print, "body", 1)));
-  }
-
-  parts.push("| ");
-  return concat(parts);
-}
-
-function printBlock(braces) {
-  return function printBlockWithBraces(path, opts, print) {
-    const [variables, statements] = path.getValue().body;
-    const stmts =
-      statements.type === "stmts" ? statements.body : statements.body[0].body;
-
-    let doBlockBody = "";
-    if (
-      stmts.length !== 1 ||
-      stmts[0].type !== "void_stmt" ||
-      stmts[0].comments
-    ) {
-      doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
-    }
-
-    // If this block is nested underneath a command or command_call node, then
-    // we can't use `do...end` because that will get associated with the parent
-    // node as opposed to the current node (because of the difference in
-    // operator precedence). Instead, we still use a multi-line format but
-    // switch to using braces instead.
-    const useBraces = braces && hasAncestor(path, ["command", "command_call"]);
-
-    const doBlock = concat([
-      useBraces ? " {" : " do",
-      variables ? concat([" ", path.call(print, "body", 0)]) : "",
-      doBlockBody,
-      concat([softline, useBraces ? "}" : "end"])
-    ]);
-
-    // We can hit this next pattern if within the block the only statement is a
-    // comment.
-    if (
-      stmts.length === 1 &&
-      stmts[0].type === "void_stmt" &&
-      stmts[0].comments
-    ) {
-      return concat([breakParent, doBlock]);
-    }
-
-    const blockReceiver = path.getParentNode().body[0];
-
-    // If the parent node is a command node, then there are no parentheses
-    // around the arguments to that command, so we need to break the block
-    if (["command", "command_call"].includes(blockReceiver.type)) {
-      return concat([breakParent, doBlock]);
-    }
-
-    const hasBody = stmts.some(({ type }) => type !== "void_stmt");
-    const braceBlock = concat([
-      " {",
-      hasBody || variables ? " " : "",
-      variables ? path.call(print, "body", 0) : "",
-      path.call(print, "body", 1),
-      hasBody ? " " : "",
-      "}"
-    ]);
-
-    return group(ifBreak(doBlock, braceBlock));
-  };
-}
-
-module.exports = {
-  block_var: printBlockVar,
-  brace_block: printBlock(true),
-  do_block: printBlock(false)
-};

data/src/ruby/nodes/calls.js

@@ -1,246 +0,0 @@
-const {
-  concat,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  join,
-  softline
-} = require("../../prettier");
-const { makeCall, noIndent } = require("../../utils");
-
-const toProc = require("../toProc");
-
-const chained = ["call", "method_add_arg", "method_add_block"];
-
-function printCall(path, opts, print) {
-  const node = path.getValue();
-  const [receiverNode, _operatorNode, messageNode] = node.body;
-
-  const receiverDoc = path.call(print, "body", 0);
-  const operatorDoc = makeCall(path, opts, print);
-
-  // You can call lambdas with a special syntax that looks like func.(*args).
-  // In this case, "call" is returned for the 3rd child node. We don't alter
-  // call syntax so if `call` is implicit, we don't print it out.
-  const messageDoc = messageNode === "call" ? "" : path.call(print, "body", 2);
-
-  // For certain left sides of the call nodes, we want to attach directly to
-  // the } or end.
-  if (noIndent.includes(receiverNode.type)) {
-    return concat([receiverDoc, operatorDoc, messageDoc]);
-  }
-
-  // The right side of the call node, as in everything including the operator
-  // and beyond.
-  let rightSideDoc = concat([
-    receiverNode.comments ? hardline : softline,
-    operatorDoc,
-    messageDoc
-  ]);
-
-  // This is very specialized behavior wherein we group .where.not calls
-  // together because it looks better. For more information, see
-  // https://github.com/prettier/plugin-ruby/issues/862.
-  if (
-    receiverNode.type === "call" &&
-    receiverNode.body[2].body === "where" &&
-    messageDoc === "not"
-  ) {
-    rightSideDoc = concat([operatorDoc, messageDoc]);
-  }
-
-  // Get a reference to the parent node so we can check if we're inside a chain
-  const parentNode = path.getParentNode();
-
-  // If our parent node is a chained node then we're not going to group the
-  // right side of the expression, as we want to have a nice multi-line layout.
-  if (chained.includes(parentNode.type) && !node.comments) {
-    parentNode.chain = (node.chain || 0) + 1;
-    parentNode.callChain = (node.callChain || 0) + 1;
-    parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
-    parentNode.firstReceiverType = node.firstReceiverType || receiverNode.type;
-  }
-
-  // If we're at the top of a chain, then we're going to print out a nice
-  // multi-line layout if this doesn't break into multiple lines.
-  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
-    return ifBreak(
-      group(indent(concat(node.breakDoc.concat(rightSideDoc)))),
-      concat([receiverDoc, group(rightSideDoc)])
-    );
-  }
-
-  return group(concat([receiverDoc, group(indent(rightSideDoc))]));
-}
-
-function printMethodAddArg(path, opts, print) {
-  const node = path.getValue();
-
-  const [methodNode, argNode] = node.body;
-  const [methodDoc, argsDoc] = path.map(print, "body");
-
-  // You can end up here if you have a method with a ? ending, presumably
-  // because the parser knows that it cannot be a local variable. You can also
-  // end up here if you are explicitly using an empty set of parentheses.
-  if (argsDoc.length === 0) {
-    // If you're using an explicit set of parentheses on something that looks
-    // like a constant, then we need to match that in order to maintain valid
-    // Ruby. For example, you could do something like Foo(), on which we would
-    // need to keep the parentheses to make it look like a method call.
-    if (methodNode.type === "fcall" && methodNode.body[0].type === "@const") {
-      return concat([methodDoc, "()"]);
-    }
-
-    // If you're using an explicit set parentheses with the special call syntax,
-    // then we need to explicitly print out an extra set of parentheses. For
-    // example, if you call something like Foo.new.() (implicitly calling the
-    // #call method on a new instance of the Foo class), then we have to print
-    // out those parentheses, otherwise we'll end up with Foo.new.
-    if (methodNode.type === "call" && methodNode.body[2] === "call") {
-      return concat([methodDoc, "()"]);
-    }
-
-    return methodDoc;
-  }
-
-  // This case will ONLY be hit if we can successfully turn the block into a
-  // to_proc call. In that case, we just explicitly add the parens around it.
-  if (argNode.type === "args" && argsDoc.length > 0) {
-    return concat([methodDoc, "("].concat(argsDoc).concat(")"));
-  }
-
-  // Get a reference to the parent node so we can check if we're inside a chain
-  const parentNode = path.getParentNode();
-
-  // If our parent node is a chained node then we're not going to group the
-  // right side of the expression, as we want to have a nice multi-line layout.
-  if (chained.includes(parentNode.type) && !node.comments) {
-    parentNode.chain = (node.chain || 0) + 1;
-    parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
-    parentNode.firstReceiverType = node.firstReceiverType;
-  }
-
-  // This is the threshold at which we will start to try to make a nicely
-  // indented call chain. For the most part, it's always 3.
-  let threshold = 3;
-
-  // Here, we have very specialized behavior where if we're within a sig block,
-  // then we're going to assume we're creating a Sorbet type signature. In that
-  // case, we really want the threshold to be lowered to 2 so that we create
-  // method chains off of any two method calls within the block. For more
-  // details, see
-  // https://github.com/prettier/plugin-ruby/issues/863.
-  let sigBlock = path.getParentNode(2);
-  if (sigBlock) {
-    // If we're at a do_block, then we want to go one more level up. This is
-    // because do_blocks have bodystmt nodes instead of just stmt nodes.
-    if (sigBlock.type === "do_block") {
-      sigBlock = path.getParentNode(3);
-    }
-
-    if (
-      sigBlock.type === "method_add_block" &&
-      sigBlock.body[1] &&
-      sigBlock.body[0].type === "method_add_arg" &&
-      sigBlock.body[0].body[0].type === "fcall" &&
-      sigBlock.body[0].body[0].body[0].body === "sig"
-    ) {
-      threshold = 2;
-    }
-  }
-
-  // If we're at the top of a chain, then we're going to print out a nice
-  // multi-line layout if this doesn't break into multiple lines.
-  if (!chained.includes(parentNode.type) && (node.chain || 0) >= threshold) {
-    // This is pretty specialized behavior. Basically if we're at the top of a
-    // chain but we've only had method calls without arguments and now we have
-    // arguments, then we're effectively trying to call a method with arguments
-    // that is nested under a bunch of stuff. So we group together to first part
-    // to make it so just the arguments break. This looks like, for example:
-    //
-    //     config.action_dispatch.rescue_responses.merge!(
-    //       'ActiveRecord::ConnectionTimeoutError' => :service_unavailable,
-    //       'ActiveRecord::QueryCanceled' => :service_unavailable
-    //     )
-    //
-    if (node.callChain === node.chain) {
-      return concat([group(indent(concat(node.breakDoc))), group(argsDoc)]);
-    }
-
-    return ifBreak(
-      group(indent(concat(node.breakDoc.concat(argsDoc)))),
-      concat([methodDoc, argsDoc])
-    );
-  }
-
-  // If there are already parentheses, then we can just use the doc that's
-  // already printed.
-  if (argNode.type == "arg_paren") {
-    return concat([methodDoc, argsDoc]);
-  }
-
-  return concat([methodDoc, " ", join(", ", argsDoc), " "]);
-}
-
-function printMethodAddBlock(path, opts, print) {
-  const node = path.getValue();
-
-  const [callNode, blockNode] = node.body;
-  const [callDoc, blockDoc] = path.map(print, "body");
-
-  // Don't bother trying to do any kind of fancy toProc transform if the option
-  // is disabled.
-  if (opts.rubyToProc) {
-    const proc = toProc(path, blockNode);
-
-    if (proc && callNode.type === "call") {
-      return group(
-        concat([
-          path.call(print, "body", 0),
-          "(",
-          indent(concat([softline, proc])),
-          concat([softline, ")"])
-        ])
-      );
-    }
-
-    if (proc) {
-      return path.call(print, "body", 0);
-    }
-  }
-
-  // Get a reference to the parent node so we can check if we're inside a chain
-  const parentNode = path.getParentNode();
-
-  // If our parent node is a chained node then we're not going to group the
-  // right side of the expression, as we want to have a nice multi-line layout.
-  if (chained.includes(parentNode.type)) {
-    parentNode.chain = (node.chain || 0) + 1;
-    parentNode.breakDoc = (node.breakDoc || [callDoc]).concat(blockDoc);
-    parentNode.firstReceiverType = node.firstReceiverType;
-  }
-
-  // If we're at the top of a chain, then we're going to print out a nice
-  // multi-line layout if this doesn't break into multiple lines.
-  if (!chained.includes(parentNode.type) && (node.chain || 0) >= 3) {
-    return ifBreak(
-      group(indent(concat(node.breakDoc.concat(blockDoc)))),
-      concat([callDoc, blockDoc])
-    );
-  }
-
-  return concat([callDoc, blockDoc]);
-}
-
-function printCallContainer(path, opts, print) {
-  return path.call(print, "body", 0);
-}
-
-module.exports = {
-  call: printCall,
-  fcall: printCallContainer,
-  method_add_arg: printMethodAddArg,
-  method_add_block: printMethodAddBlock,
-  vcall: printCallContainer
-};

data/src/ruby/nodes/case.js

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

@@ -1,64 +0,0 @@
-const { concat, group, hardline, indent } = require("../../prettier");
-const { isEmptyBodyStmt } = require("../../utils");
-
-function printClass(path, opts, print) {
-  const [_constant, superclass, bodystmt] = path.getValue().body;
-
-  const parts = ["class ", path.call(print, "body", 0)];
-  if (superclass) {
-    parts.push(" < ", path.call(print, "body", 1));
-  }
-
-  const declaration = group(concat(parts));
-  if (isEmptyBodyStmt(bodystmt)) {
-    return group(concat([declaration, hardline, "end"]));
-  }
-
-  return group(
-    concat([
-      declaration,
-      indent(concat([hardline, path.call(print, "body", 2)])),
-      concat([hardline, "end"])
-    ])
-  );
-}
-
-function printModule(path, opts, print) {
-  const node = path.getValue();
-  const declaration = group(concat(["module ", path.call(print, "body", 0)]));
-
-  if (isEmptyBodyStmt(node.body[1])) {
-    return group(concat([declaration, hardline, "end"]));
-  }
-
-  return group(
-    concat([
-      declaration,
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      concat([hardline, "end"])
-    ])
-  );
-}
-
-function printSClass(path, opts, print) {
-  const bodystmt = path.getValue().body[1];
-  const declaration = concat(["class << ", path.call(print, "body", 0)]);
-
-  if (isEmptyBodyStmt(bodystmt)) {
-    return group(concat([declaration, hardline, "end"]));
-  }
-
-  return group(
-    concat([
-      declaration,
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      concat([hardline, "end"])
-    ])
-  );
-}
-
-module.exports = {
-  class: printClass,
-  module: printModule,
-  sclass: printSClass
-};

data/src/ruby/nodes/commands.js

@@ -1,131 +0,0 @@
-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(docLength(command) + 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])) {
-    breakDoc = parts.concat(
-      "(",
-      indent(concat([softline, argDocs])),
-      softline,
-      ")"
-    );
-    parts.push(" ");
-  } 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
-};