prettier 0.20.0 → 1.0.0.pre.rc2

data/src/nodes/regexp.js

@@ -1,18 +1,42 @@
 const { concat } = require("../prettier");
-const { makeList } = require("../utils");
 
-module.exports = {
-  regexp: makeList,
-  regexp_literal: (path, opts, print) => {
-    const [contents, ending] = path.map(print, "body");
-
-    const useBraces = contents.some(
-      (content) => typeof content === "string" && content.includes("/")
-    );
-    const parts = [useBraces ? "%r{" : "/"]
-      .concat(contents)
-      .concat([useBraces ? "}" : "/", ending.slice(1)]);
-
-    return concat(parts);
+function isStringContent(node) {
+  return node.type === "@tstring_content";
+}
+
+function shouldUseBraces(node) {
+  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])) {
+    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(node);
+
+  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/rescue.js

@@ -9,73 +9,86 @@ const {
 } = require("../prettier");
 const { literal } = require("../utils");
 
-module.exports = {
-  begin: (path, opts, print) =>
-    concat([
-      "begin",
-      indent(concat([hardline, concat(path.map(print, "body"))])),
-      hardline,
-      "end"
-    ]),
-  ensure: (path, opts, print) =>
-    concat([
-      "ensure",
-      indent(concat([hardline, concat(path.map(print, "body"))]))
-    ]),
-  redo: literal("redo"),
-  rescue: (path, opts, print) => {
-    const [exception, variable, _stmts, addition] = path.getValue().body;
-    const parts = ["rescue"];
+function printBegin(path, opts, print) {
+  return concat([
+    "begin",
+    indent(concat([hardline, concat(path.map(print, "body"))])),
+    hardline,
+    "end"
+  ]);
+}
 
-    if (exception || variable) {
-      if (exception) {
-        if (Array.isArray(exception)) {
-          // In this case, it's actually only the one exception (it's an array
-          // of length 1).
-          parts.push(" ", path.call(print, "body", 0, 0));
-        } else {
-          // Here we have multiple exceptions from which we're rescuing, so we
-          // need to align them and join them together.
-          const joiner = concat([",", line]);
-          const exceptions = group(join(joiner, path.call(print, "body", 0)));
+function printEnsure(path, opts, print) {
+  return concat([
+    path.call(print, "body", 0),
+    indent(concat([hardline, path.call(print, "body", 1)]))
+  ]);
+}
 
-          parts.push(" ", align("rescue ".length, exceptions));
-        }
-      }
+function printRescue(path, opts, print) {
+  const [exception, variable, _stmts, addition] = path.getValue().body;
+  const parts = ["rescue"];
+
+  if (exception || variable) {
+    if (exception) {
+      if (Array.isArray(exception)) {
+        // In this case, it's actually only the one exception (it's an array
+        // of length 1).
+        parts.push(" ", path.call(print, "body", 0, 0));
+      } else {
+        // Here we have multiple exceptions from which we're rescuing, so we
+        // need to align them and join them together.
+        const joiner = concat([",", line]);
+        const exceptions = group(join(joiner, path.call(print, "body", 0)));
 
-      if (variable) {
-        parts.push(" => ", path.call(print, "body", 1));
+        parts.push(" ", align("rescue ".length, exceptions));
       }
-    } 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 rescueBody = path.call(print, "body", 2);
-
-    if (rescueBody.parts.length > 0) {
-      parts.push(indent(concat([hardline, rescueBody])));
+    if (variable) {
+      parts.push(" => ", path.call(print, "body", 1));
     }
+  } 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");
+  }
 
-    // This is the next clause on the `begin` statement, either another
-    // `rescue`, and `ensure`, or an `else` clause.
-    if (addition) {
-      parts.push(concat([hardline, path.call(print, "body", 3)]));
-    }
+  const rescueBody = path.call(print, "body", 2);
+
+  if (rescueBody.parts.length > 0) {
+    parts.push(indent(concat([hardline, rescueBody])));
+  }
 
-    return group(concat(parts));
-  },
-  rescue_mod: (path, opts, print) =>
-    concat([
-      "begin",
-      indent(concat([hardline, path.call(print, "body", 0)])),
-      hardline,
-      "rescue StandardError",
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      hardline,
-      "end"
-    ]),
+  // This is the next clause on the `begin` statement, either another
+  // `rescue`, and `ensure`, or an `else` clause.
+  if (addition) {
+    parts.push(concat([hardline, path.call(print, "body", 3)]));
+  }
+
+  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_mod: printRescueMod,
   retry: literal("retry")
 };

data/src/nodes/statements.js

@@ -1,4 +1,5 @@
 const {
+  breakParent,
   concat,
   dedent,
   group,
@@ -11,63 +12,104 @@ const {
   trim
 } = require("../prettier");
 
-module.exports = {
-  "@__end__": (path, _opts, _print) => {
-    const { body } = path.getValue();
-    return concat([trim, "__END__", literalline, body]);
-  },
-  bodystmt: (path, opts, print) => {
-    const [_statements, rescue, elseClause, ensure] = path.getValue().body;
-    const parts = [path.call(print, "body", 0)];
+function printBodyStmt(path, opts, print) {
+  const [stmts, rescue, elseClause, ensure] = path.getValue().body;
+  const parts = [];
 
-    if (rescue) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
-    }
+  if (
+    stmts.body.length > 1 ||
+    stmts.body[0].type != "void_stmt" ||
+    stmts.body[0].comments
+  ) {
+    parts.push(path.call(print, "body", 0));
+  }
 
-    if (elseClause) {
-      // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-      const stmts =
-        elseClause.type === "else"
-          ? path.call(print, "body", 2, "body", 0)
-          : path.call(print, "body", 2);
+  if (rescue) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
+  }
 
-      parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
-    }
+  if (elseClause) {
+    // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+    const stmts =
+      elseClause.type === "else"
+        ? path.call(print, "body", 2, "body", 0)
+        : path.call(print, "body", 2);
 
-    if (ensure) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
-    }
+    parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
+  }
 
-    return group(concat(parts));
-  },
-  embdoc: (path, _opts, _print) => concat([trim, path.getValue().body]),
-  paren: (path, opts, print) => {
-    if (!path.getValue().body[0]) {
-      return "()";
-    }
+  if (ensure) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
+  }
 
-    let content = path.call(print, "body", 0);
+  return group(concat(parts));
+}
 
-    if (
-      ["args", "args_add_star", "args_add_block"].includes(
-        path.getValue().body[0].type
-      )
-    ) {
-      content = join(concat([",", line]), content);
-    }
+const argNodeTypes = ["args", "args_add_star", "args_add_block"];
+
+function printParen(path, opts, print) {
+  const contentNode = path.getValue().body[0];
 
-    return group(
-      concat([
-        "(",
-        indent(concat([softline, content])),
-        concat([softline, ")"])
-      ])
-    );
+  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])),
+      concat([softline, ")"])
+    ])
+  );
+}
+
+module.exports = {
+  "@__end__": (path, _opts, _print) => {
+    const { body } = path.getValue();
+    return concat([trim, "__END__", literalline, body]);
   },
+  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, index) => {
+          stmts[0].comments[index].printed = true;
+          return opts.printer.printComment(commentPath);
+        },
+        "body",
+        0,
+        "comments"
+      );
+
+      return concat([breakParent, join(hardline, comments)]);
+    }
+
     const parts = [];
     let lineNo = null;
 

data/src/nodes/strings.js

@@ -8,30 +8,30 @@ const {
   join
 } = require("../prettier");
 
-const { concatBody, empty, makeList, prefix, surround } = require("../utils");
-
 // 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.)
-const isQuoteLocked = (string) =>
-  string.body.some(
+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.
-const isSingleQuotable = (string) =>
-  string.body.every(
+function isSingleQuotable(node) {
+  return node.body.every(
     (part) => part.type === "@tstring_content" && !part.body.includes("'")
   );
+}
 
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
-const normalizeQuotes = (content, enclosingQuote, originalQuote) => {
+function normalizeQuotes(content, enclosingQuote, originalQuote) {
   const replaceOther = ["'", '"'].includes(originalQuote);
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
 
@@ -52,7 +52,7 @@ const normalizeQuotes = (content, enclosingQuote, originalQuote) => {
 
     return `\\${escaped}`;
   });
-};
+}
 
 const quotePairs = {
   "(": ")",
@@ -61,51 +61,100 @@ const quotePairs = {
   "<": ">"
 };
 
-const getClosingQuote = (quote) => {
+function getClosingQuote(quote) {
   if (!quote.startsWith("%")) {
     return quote;
   }
 
-  const boundary = /%q?(.)/.exec(quote)[1];
+  const boundary = /%[Qq]?(.)/.exec(quote)[1];
   if (boundary in quotePairs) {
     return quotePairs[boundary];
   }
 
   return boundary;
-};
+}
 
-module.exports = {
-  "@CHAR": (path, { preferSingleQuotes }, _print) => {
-    const { body } = path.getValue();
+// 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]);
+}
+
+// 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.
+function printDynaSymbol(path, opts, print) {
+  const { quote } = path.getValue();
+
+  return concat([":", quote].concat(path.map(print, "body")).concat(quote));
+}
+
+// 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), "}"]);
+}
+
+// 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) ? "'" : '"';
+  }
 
-    if (body.length !== 2) {
-      return body;
+  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);
     }
 
-    const quote = preferSingleQuotes ? "'" : '"';
-    return body.length === 2 ? concat([quote, body.slice(1), quote]) : body;
-  },
-  dyna_symbol: (path, opts, print) => {
-    const { quote } = path.getValue();
+    // In this case, the part of the string is just regular string content
+    return join(
+      literalline,
+      normalizeQuotes(part.body, quote, node.quote).split("\n")
+    );
+  });
 
-    return concat([":", quote, concat(path.call(print, "body", 0)), quote]);
-  },
-  heredoc: (path, opts, print) => {
-    const { beging, body, ending } = path.getValue();
+  return concat([quote].concat(parts).concat(getClosingQuote(quote)));
+}
 
-    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);
-      }
+// 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)]);
+}
 
-      // In this case, the part of the string is just regular string content
-      return join(literalline, part.body.split("\n"));
-    });
+// 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("`"));
+}
 
-    return concat([beging, literalline, concat(parts), ending]);
-  },
-  string: makeList,
+module.exports = {
+  "@CHAR": printChar,
+  dyna_symbol: printDynaSymbol,
   string_concat: (path, opts, print) =>
     group(
       concat([
@@ -114,14 +163,15 @@ module.exports = {
         indent(concat([hardline, path.call(print, "body", 1)]))
       ])
     ),
-  string_dvar: surround("#{", "}"),
+  string_dvar: printStringDVar,
   string_embexpr: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 
-    // If the interpolated expression is inside of an xstring literal (a string
-    // that gets sent to the command line) then we don't want to automatically
-    // indent, as this can lead to some very odd looking expressions
-    if (path.getParentNode().type === "xstring") {
+    // If the interpolated expression is inside of a heredoc or an xstring
+    // literal (a string that gets sent to the command line) then we don't want
+    // to automatically indent, as this can lead to some very odd looking
+    // expressions
+    if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
       return concat(["#{", parts, "}"]);
     }
 
@@ -129,53 +179,7 @@ module.exports = {
       concat(["#{", indent(concat([softline, parts])), concat([softline, "}"])])
     );
   },
-  string_literal: (path, { preferSingleQuotes }, print) => {
-    const stringLiteral = path.getValue();
-    const string = stringLiteral.body[0];
-
-    // If this string is actually a heredoc, bail out and return to the print
-    // function for heredocs
-    if (string.type === "heredoc") {
-      return path.call(print, "body", 0);
-    }
-
-    // If the string is empty, it will not have any parts, so just print out the
-    // quotes corresponding to the config
-    if (string.body.length === 0) {
-      return preferSingleQuotes ? "''" : '""';
-    }
-
-    // Determine the quote that should enclose the new string
-    let quote;
-    if (isQuoteLocked(string)) {
-      ({ quote } = stringLiteral);
-    } else {
-      quote = preferSingleQuotes && isSingleQuotable(string) ? "'" : '"';
-    }
-
-    const parts = string.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", 0, "body", index);
-      }
-
-      // In this case, the part of the string is just regular string content
-      return join(
-        literalline,
-        normalizeQuotes(part.body, quote, stringLiteral.quote).split("\n")
-      );
-    });
-
-    return concat([quote].concat(parts).concat(getClosingQuote(quote)));
-  },
-  symbol: prefix(":"),
-  symbol_literal: concatBody,
-  word_add: concatBody,
-  word_new: empty,
-  xstring: makeList,
-  xstring_literal: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    return concat(["`"].concat(parts).concat("`"));
-  }
+  string_literal: printStringLiteral,
+  symbol_literal: printSymbolLiteral,
+  xstring_literal: printXStringLiteral
 };