prettier 1.6.1 → 2.0.0.pre.rc1

data/src/ruby/embed.js

@@ -1,142 +0,0 @@
-const {
-  concat,
-  group,
-  indent,
-  lineSuffix,
-  mapDoc,
-  markAsRoot,
-  stripTrailingHardline
-} = require("../prettier");
-
-const { literallineWithoutBreakParent } = require("../utils");
-
-const parsers = {
-  css: "css",
-  javascript: "babel",
-  js: "babel",
-  less: "less",
-  markdown: "markdown",
-  ruby: "ruby",
-  scss: "scss"
-};
-
-// This function is in here because it handles embedded parser values. I don't
-// have a test that exercises it because I'm not sure for which parser it is
-// necessary, but since it's in prettier core I'm keeping it here.
-/* istanbul ignore next */
-function replaceNewlines(doc) {
-  return mapDoc(doc, (currentDoc) =>
-    typeof currentDoc === "string" && currentDoc.includes("\n")
-      ? concat(
-          currentDoc
-            .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literallineWithoutBreakParent))
-        )
-      : currentDoc
-  );
-}
-
-// Returns a number that represents the minimum amount of leading whitespace
-// that is present on every line in the given string. So for example if you have
-// the following heredoc:
-//
-//     <<~HERE
-//       my
-//       content
-//       here
-//     HERE
-//
-// then the return value of this function would be 2. If you indented every line
-// of the inner content 2 more spaces then this function would return 4.
-function getCommonLeadingWhitespace(content) {
-  const pattern = /^\s+/;
-
-  return content
-    .split("\n")
-    .slice(0, -1)
-    .reduce((minimum, line) => {
-      const matched = pattern.exec(line);
-      const length = matched ? matched[0].length : 0;
-
-      return minimum === null ? length : Math.min(minimum, length);
-    }, null);
-}
-
-// Returns a new string with the common whitespace stripped out. Effectively it
-// emulates what a squiggly heredoc does in Ruby.
-function stripCommonLeadingWhitespace(content) {
-  const lines = content.split("\n");
-  const minimum = getCommonLeadingWhitespace(content);
-
-  return lines.map((line) => line.slice(minimum)).join("\n");
-}
-
-function embed(path, print, textToDoc, _opts) {
-  const node = path.getValue();
-
-  // Currently we only support embedded formatting on heredoc nodes
-  if (node.type !== "heredoc") {
-    return null;
-  }
-
-  // First, ensure that we don't have any interpolation
-  const { beging, body, ending } = node;
-  const isSquiggly = beging.body[2] === "~";
-
-  if (body.some((part) => part.type !== "@tstring_content")) {
-    return null;
-  }
-
-  // Next, find the parser associated with this heredoc (if there is one). For
-  // example, if you use <<~CSS, we'd hook it up to the css parser.
-  const parser = parsers[beging.body.slice(3).toLowerCase()];
-  if (!parser) {
-    return null;
-  }
-
-  // Get the content as if it were a source string.
-  let content = body.map((part) => part.body).join("");
-
-  // If we're using a squiggly heredoc, then we're going to manually strip off
-  // the leading whitespace of each line up to the minimum leading whitespace so
-  // that the embedded parser can handle that for us.
-  if (isSquiggly) {
-    content = stripCommonLeadingWhitespace(content);
-  }
-
-  // Pass that content into the embedded parser. Get back the doc node.
-  const formatted = concat([
-    literallineWithoutBreakParent,
-    replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
-  ]);
-
-  // If we're using a squiggly heredoc, then we can properly handle indentation
-  // ourselves.
-  if (isSquiggly) {
-    return concat([
-      path.call(print, "beging"),
-      lineSuffix(
-        group(
-          concat([
-            indent(markAsRoot(formatted)),
-            literallineWithoutBreakParent,
-            ending.trim()
-          ])
-        )
-      )
-    ]);
-  }
-
-  // Otherwise, we need to just assume it's formatted correctly and return the
-  // content as it is.
-  return markAsRoot(
-    concat([
-      path.call(print, "beging"),
-      lineSuffix(
-        group(concat([formatted, literallineWithoutBreakParent, ending.trim()]))
-      )
-    ])
-  );
-}
-
-module.exports = embed;

data/src/ruby/nodes/alias.js

@@ -1,73 +0,0 @@
-const {
-  addTrailingComment,
-  align,
-  concat,
-  group,
-  hardline,
-  line
-} = require("../../prettier");
-
-// In general, return the printed doc of the argument at the provided index.
-// Special handling is given for symbol literals that are not bare words, as we
-// convert those into bare words by just pulling out the ident node.
-function printAliasArgument(path, print, argIndex) {
-  const node = path.getValue().body[argIndex];
-
-  if (node.type === "symbol_literal") {
-    // If we're going to descend into the symbol literal to grab out the ident
-    // node, then we need to make sure we copy over any comments as well,
-    // otherwise we could accidentally skip printing them.
-    if (node.comments) {
-      node.comments.forEach((comment) => {
-        addTrailingComment(node.body[0], comment);
-      });
-    }
-
-    return path.call(print, "body", argIndex, "body", 0);
-  }
-
-  return path.call(print, "body", argIndex);
-}
-
-// The `alias` keyword is used to make a method respond to another name as well
-// as the current one. For example, to get the method `foo` to also respond to
-// `bar`, you would:
-//
-//     alias bar foo
-//
-// Now, in the current context you can call `bar` and it will execute the `foo`
-// method.
-//
-// When you're aliasing two methods, you can either provide bare words (like the
-// example above) or you can provide symbols (note that this includes dynamic
-// symbols like :"foo-#{bar}-baz"). In general, to be consistent with the ruby
-// style guide, we prefer bare words:
-//
-//     https://github.com/rubocop-hq/ruby-style-guide#alias-method-lexically
-//
-// The `alias` node contains two children. The left and right align with the
-// arguments passed to the keyword. So, for the above example the left would be
-// the symbol literal `bar` and the right could be the symbol literal `foo`.
-function printAlias(path, opts, print) {
-  const keyword = "alias ";
-
-  const rightSide = concat([
-    // If the left child has any comments, then we need to explicitly break this
-    // into two lines
-    path.getValue().body[0].comments ? hardline : line,
-    printAliasArgument(path, print, 1)
-  ]);
-
-  return group(
-    concat([
-      keyword,
-      printAliasArgument(path, print, 0),
-      group(align(keyword.length, rightSide))
-    ])
-  );
-}
-
-module.exports = {
-  alias: printAlias,
-  var_alias: printAlias
-};

data/src/ruby/nodes/args.js

@@ -1,222 +0,0 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  line,
-  softline
-} = require("../../prettier");
-const { getTrailingComma } = require("../../utils");
-const toProc = require("../toProc");
-
-const noTrailingComma = ["command", "command_call"];
-
-function getArgParenTrailingComma(node) {
-  // If we have a block, then we don't want to add a trailing comma.
-  if (node.type === "args_add_block" && node.body[1]) {
-    return "";
-  }
-
-  // If we only have one argument and that first argument necessitates that we
-  // skip putting a comma (because it would interfere with parsing the argument)
-  // then we don't want to add a trailing comma.
-  if (node.body.length === 1 && noTrailingComma.includes(node.body[0].type)) {
-    return "";
-  }
-
-  return ifBreak(",", "");
-}
-
-function printArgParen(path, opts, print) {
-  const argsNode = path.getValue().body[0];
-
-  if (argsNode === null) {
-    return "";
-  }
-
-  // Here we can skip the entire rest of the method by just checking if it's
-  // an args_forward node, as we're guaranteed that there are no other arg
-  // nodes.
-  if (argsNode.type === "args_forward") {
-    return group(
-      concat([
-        "(",
-        indent(concat([softline, path.call(print, "body", 0)])),
-        softline,
-        ")"
-      ])
-    );
-  }
-
-  // Now here we return a doc that represents the whole grouped expression,
-  // including the surrouding parentheses.
-  return group(
-    concat([
-      "(",
-      indent(
-        concat([
-          softline,
-          join(concat([",", line]), path.call(print, "body", 0)),
-          getTrailingComma(opts) ? getArgParenTrailingComma(argsNode) : ""
-        ])
-      ),
-      softline,
-      ")"
-    ])
-  );
-}
-
-function printArgs(path, { rubyToProc }, print) {
-  const args = path.map(print, "body");
-
-  // Don't bother trying to do any kind of fancy toProc transform if the
-  // option is disabled.
-  if (rubyToProc) {
-    let blockNode = null;
-
-    // Look up the chain to see if these arguments are contained within a
-    // method_add_block node, and if they are that that node has a block
-    // associated with it. If it does, we're going to attempt to transform it
-    // into the to_proc shorthand and add it to the list of arguments.
-    [1, 2, 3].find((parent) => {
-      const parentNode = path.getParentNode(parent);
-      blockNode =
-        parentNode &&
-        parentNode.type === "method_add_block" &&
-        parentNode.body[1];
-
-      return blockNode;
-    });
-
-    const proc = blockNode && toProc(path, blockNode);
-
-    // If we have a successful to_proc transformation, but we're part of an
-    // aref node, that means it's something to the effect of
-    //
-    //     foo[:bar].each(&:to_s)
-    //
-    // In this case we need to just return regular arguments, otherwise we
-    // would end up putting &:to_s inside the brackets accidentally.
-    if (proc && path.getParentNode(1).type !== "aref") {
-      args.push(proc);
-    }
-  }
-
-  return args;
-}
-
-function printArgsAddBlock(path, opts, print) {
-  const node = path.getValue();
-  const blockNode = node.body[1];
-
-  const parts = path.call(print, "body", 0);
-
-  if (blockNode) {
-    let blockDoc = path.call(print, "body", 1);
-
-    if (!(blockNode.comments || []).some(({ leading }) => leading)) {
-      // If we don't have any leading comments, we can just prepend the
-      // operator.
-      blockDoc = concat(["&", blockDoc]);
-    } else if (Array.isArray(blockDoc[0])) {
-      // If we have a method call like:
-      //
-      //     foo(
-      //       # comment
-      //       &block
-      //     )
-      //
-      // then we need to make sure we don't accidentally prepend the operator
-      // before the comment.
-      //
-      // In prettier >= 2.3.0, the comments are printed as an array before the
-      // content. I don't love this kind of reflection, but it's the simplest
-      // way at the moment to get this right.
-      blockDoc = blockDoc[0].concat(
-        concat(["&", blockDoc[1]]),
-        blockDoc.slice(2)
-      );
-    } else {
-      // In prettier < 2.3.0, the comments are printed as part of a concat, so
-      // we can reflect on how many leading comments there are to determine
-      // which doc node we should modify.
-      const index = blockNode.comments.filter(({ leading }) => leading).length;
-      blockDoc.parts[index] = concat(["&", blockDoc.parts[index]]);
-    }
-
-    parts.push(blockDoc);
-  }
-
-  return parts;
-}
-
-function printArgsAddStar(path, opts, print) {
-  let docs = [];
-
-  path.each((argPath, argIndex) => {
-    const doc = print(argPath);
-
-    // If it's the first child, then it's an array of args, so we're going to
-    // concat that onto the existing docs if there are any.
-    if (argIndex === 0) {
-      if (doc.length > 0) {
-        docs = docs.concat(doc);
-      }
-      return;
-    }
-
-    // If it's after the splat, then it's an individual arg, so we're just going
-    // to push it onto the array.
-    if (argIndex !== 1) {
-      docs.push(doc);
-      return;
-    }
-
-    // If we don't have any leading comments, we can just prepend the operator.
-    const argsNode = argPath.getValue();
-    if (!(argsNode.comments || []).some(({ leading }) => leading)) {
-      docs.push(concat(["*", doc]));
-      return;
-    }
-
-    // If we have an array like:
-    //
-    //     [
-    //       # comment
-    //       *values
-    //     ]
-    //
-    // then we need to make sure we don't accidentally prepend the operator
-    // before the comment(s).
-    //
-    // In prettier >= 2.3.0, the comments are printed as an array before the
-    // content. I don't love this kind of reflection, but it's the simplest way
-    // at the moment to get this right.
-    if (Array.isArray(doc[0])) {
-      docs.push(doc[0].concat(concat(["*", doc[1]]), doc.slice(2)));
-      return;
-    }
-
-    // In prettier < 2.3.0, the comments are printed as part of a concat, so
-    // we can reflect on how many leading comments there are to determine which
-    // doc node we should modify.
-    const index = argsNode.comments.filter(({ leading }) => leading).length;
-    doc.parts[index] = concat(["*", doc.parts[index]]);
-    docs = docs.concat(doc);
-  }, "body");
-
-  return docs;
-}
-
-function printBlockArg(path, opts, print) {
-  return concat(["&", path.call(print, "body", 0)]);
-}
-
-module.exports = {
-  arg_paren: printArgParen,
-  args: printArgs,
-  args_add_block: printArgsAddBlock,
-  args_add_star: printArgsAddStar,
-  blockarg: printBlockArg
-};

data/src/ruby/nodes/arrays.js

@@ -1,162 +0,0 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  join,
-  line,
-  softline
-} = require("../../prettier");
-const { getTrailingComma, printEmptyCollection } = require("../../utils");
-
-// Checks that every argument within this args node is a string_literal node
-// that has no spaces or interpolations. This means we're dealing with an array
-// that looks something like:
-//
-//     ['a', 'b', 'c']
-//
-function isStringArray(args) {
-  return (
-    args.body.length > 1 &&
-    args.body.every((arg) => {
-      // We want to verify that every node inside of this array is a string
-      // literal. We also want to make sure none of them have comments attached.
-      if (arg.type !== "string_literal" || arg.comments) {
-        return false;
-      }
-
-      // If the string has multiple parts (meaning plain string content but also
-      // interpolated content) then we know it's not a simple string.
-      if (arg.body.length !== 1) {
-        return false;
-      }
-
-      const part = arg.body[0];
-
-      // If the only part of this string is not @tstring_content then it's
-      // interpolated, so again we can return false.
-      if (part.type !== "@tstring_content") {
-        return false;
-      }
-
-      // Finally, verify that the string doesn't contain a space, an escape
-      // character, or brackets so that we know it can be put into a string
-      // literal array.
-      return !/[\s\\[\]]/.test(part.body);
-    })
-  );
-}
-
-// Checks that every argument within this args node is a symbol_literal node (as
-// opposed to a dyna_symbol) so it has no interpolation. This means we're
-// dealing with an array that looks something like:
-//
-//     [:a, :b, :c]
-//
-function isSymbolArray(args) {
-  return (
-    args.body.length > 1 &&
-    args.body.every((arg) => arg.type === "symbol_literal" && !arg.comments)
-  );
-}
-
-// Prints out a word that is a part of a special array literal that accepts
-// interpolation. The body is an array of either plain strings or interpolated
-// expressions.
-function printArrayLiteralWord(path, opts, print) {
-  return concat(path.map(print, "body"));
-}
-
-// Prints out a special array literal. Accepts the parts of the array literal as
-// an argument, where the first element of the parts array is a string that
-// contains the special start.
-function printArrayLiteral(start, parts) {
-  return group(
-    concat([
-      start,
-      "[",
-      indent(concat([softline, join(line, parts)])),
-      concat([softline, "]"])
-    ])
-  );
-}
-
-const arrayLiteralStarts = {
-  qsymbols: "%i",
-  qwords: "%w",
-  symbols: "%I",
-  words: "%W"
-};
-
-// An array node is any literal array in Ruby. This includes all of the special
-// array literals as well as regular arrays. If it is a special array literal
-// then it will have one child that represents the special array, otherwise it
-// will have one child that contains all of the elements of the array.
-function printArray(path, opts, print) {
-  const array = path.getValue();
-  const args = array.body[0];
-
-  // If there is no inner arguments node, then we're dealing with an empty
-  // array, so we can go ahead and return.
-  if (args === null) {
-    return printEmptyCollection(path, opts, "[", "]");
-  }
-
-  if (opts.rubyArrayLiteral) {
-    // If we have an array that contains only simple string literals with no
-    // spaces or interpolation, then we're going to print a %w array.
-    if (isStringArray(args)) {
-      const printString = (stringPath) => stringPath.call(print, "body", 0);
-      const parts = path.map(printString, "body", 0, "body");
-
-      return printArrayLiteral("%w", parts);
-    }
-
-    // If we have an array that contains only simple symbol literals with no
-    // interpolation, then we're going to print a %i array.
-    if (isSymbolArray(args)) {
-      const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
-      const parts = path.map(printSymbol, "body", 0, "body");
-
-      return printArrayLiteral("%i", parts);
-    }
-  }
-
-  // If we don't have a regular args node at this point then we have a special
-  // array literal. In that case we're going to print out the body (which will
-  // return to us an array with the first one being the start of the array) and
-  // send that over to the printArrayLiteral function.
-  if (!["args", "args_add_star"].includes(args.type)) {
-    return path.call(
-      (arrayPath) =>
-        printArrayLiteral(
-          arrayLiteralStarts[arrayPath.getValue().type],
-          arrayPath.map(print, "body")
-        ),
-      "body",
-      0
-    );
-  }
-
-  // Here we have a normal array of any type of object with no special literal
-  // types or anything.
-  return group(
-    concat([
-      "[",
-      indent(
-        concat([
-          softline,
-          join(concat([",", line]), path.call(print, "body", 0)),
-          getTrailingComma(opts) ? ifBreak(",", "") : ""
-        ])
-      ),
-      softline,
-      "]"
-    ])
-  );
-}
-
-module.exports = {
-  array: printArray,
-  word: printArrayLiteralWord
-};

data/src/ruby/nodes/assign.js

@@ -1,47 +0,0 @@
-const { concat, group, indent, join, line } = require("../../prettier");
-const { skipAssignIndent } = require("../../utils");
-
-function printAssign(path, opts, print) {
-  const [_targetNode, valueNode] = path.getValue().body;
-  const [targetDoc, valueDoc] = path.map(print, "body");
-
-  let rightSideDoc = valueDoc;
-
-  // If the right side of this assignment is a multiple assignment, then we need
-  // to join it together with commas.
-  if (["mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
-    rightSideDoc = group(join(concat([",", line]), valueDoc));
-  }
-
-  if (skipAssignIndent(valueNode)) {
-    return group(concat([targetDoc, " = ", rightSideDoc]));
-  }
-
-  return group(concat([targetDoc, " =", indent(concat([line, rightSideDoc]))]));
-}
-
-function printOpAssign(path, opts, print) {
-  return group(
-    concat([
-      path.call(print, "body", 0),
-      " ",
-      path.call(print, "body", 1),
-      indent(concat([line, path.call(print, "body", 2)]))
-    ])
-  );
-}
-
-function printVarField(path, opts, print) {
-  return path.getValue().body ? path.call(print, "body", 0) : "";
-}
-
-function printVarRef(path, opts, print) {
-  return path.call(print, "body", 0);
-}
-
-module.exports = {
-  assign: printAssign,
-  opassign: printOpAssign,
-  var_field: printVarField,
-  var_ref: printVarRef
-};