prettier 1.4.0 → 1.5.0

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/plugin.js",
   "scripts": {

data/src/plugin.js

@@ -36,6 +36,7 @@ module.exports = {
         ".rabl",
         ".rake",
         ".rb",
+        ".rbi",
         ".rbuild",
         ".rbw",
         ".rbx",

data/src/rbs/parser.rb

@@ -23,8 +23,14 @@ end
 class RBS::Location
   def to_json(*args)
     {
-      start: { line: start_line, column: start_column },
-      end: { line: end_line, column: end_column },
+      start: {
+        line: start_line,
+        column: start_column
+      },
+      end: {
+        line: end_line,
+        column: end_column
+      },
       start_pos: start_pos,
       end_pos: end_pos
     }.to_json(*args)

data/src/ruby/embed.js

@@ -24,8 +24,8 @@ const parsers = {
 // 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 */
-const replaceNewlines = (doc) =>
-  mapDoc(doc, (currentDoc) =>
+function replaceNewlines(doc) {
+  return mapDoc(doc, (currentDoc) =>
     typeof currentDoc === "string" && currentDoc.includes("\n")
       ? concat(
           currentDoc
@@ -34,8 +34,44 @@ const replaceNewlines = (doc) =>
         )
       : currentDoc
   );
+}
 
-const embed = (path, print, textToDoc, _opts) => {
+// 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
@@ -45,6 +81,8 @@ const embed = (path, print, textToDoc, _opts) => {
 
   // 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;
   }
@@ -56,9 +94,17 @@ const embed = (path, print, textToDoc, _opts) => {
     return null;
   }
 
-  // Get the content as if it were a source string, and then pass that content
-  // into the embedded parser. Get back the doc node.
-  const content = body.map((part) => part.body).join("");
+  // 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([
     literalLineNoBreak,
     replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
@@ -66,7 +112,7 @@ const embed = (path, print, textToDoc, _opts) => {
 
   // If we're using a squiggly heredoc, then we can properly handle indentation
   // ourselves.
-  if (beging.body[2] === "~") {
+  if (isSquiggly) {
     return concat([
       path.call(print, "beging"),
       lineSuffix(
@@ -89,6 +135,6 @@ const embed = (path, print, textToDoc, _opts) => {
       lineSuffix(group(concat([formatted, literalLineNoBreak, ending.trim()])))
     ])
   );
-};
+}
 
 module.exports = embed;

data/src/ruby/nodes/args.js

@@ -8,9 +8,26 @@ const {
   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];
 
@@ -32,9 +49,6 @@ function printArgParen(path, opts, print) {
     );
   }
 
-  const args = path.call(print, "body", 0);
-  const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
-
   // Now here we return a doc that represents the whole grouped expression,
   // including the surrouding parentheses.
   return group(
@@ -43,8 +57,8 @@ function printArgParen(path, opts, print) {
       indent(
         concat([
           softline,
-          join(concat([",", line]), args),
-          getTrailingComma(opts) && !hasBlock ? ifBreak(",", "") : ""
+          join(concat([",", line]), path.call(print, "body", 0)),
+          getTrailingComma(opts) && getArgParenTrailingComma(argsNode)
         ])
       ),
       softline,

data/src/ruby/nodes/class.js

@@ -1,34 +1,22 @@
-const {
-  concat,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  line
-} = require("../../prettier");
+const { concat, group, hardline, indent } = require("../../prettier");
+const { isEmptyBodyStmt } = require("../../utils");
 
 function printClass(path, opts, print) {
   const [_constant, superclass, bodystmt] = path.getValue().body;
-  const stmts = bodystmt.body[0];
 
   const parts = ["class ", path.call(print, "body", 0)];
   if (superclass) {
     parts.push(" < ", path.call(print, "body", 1));
   }
 
-  // If the body is empty and does not contain any comments, we can just
-  // replace the body with a semi-colon.
-  if (
-    stmts.body.length === 1 &&
-    stmts.body[0].type === "void_stmt" &&
-    !stmts.body[0].comments
-  ) {
-    return group(concat([concat(parts), ifBreak(line, "; "), "end"]));
+  const declaration = group(concat(parts));
+  if (isEmptyBodyStmt(bodystmt)) {
+    return group(concat([declaration, hardline, "end"]));
   }
 
   return group(
     concat([
-      concat(parts),
+      declaration,
       indent(concat([hardline, path.call(print, "body", 2)])),
       concat([hardline, "end"])
     ])
@@ -36,16 +24,11 @@ function printClass(path, opts, print) {
 }
 
 function printModule(path, opts, print) {
+  const node = path.getValue();
   const declaration = group(concat(["module ", path.call(print, "body", 0)]));
 
-  // If the body is empty, we can replace with a ;
-  const stmts = path.getValue().body[1].body[0];
-  if (
-    stmts.body.length === 1 &&
-    stmts.body[0].type === "void_stmt" &&
-    !stmts.body[0].comments
-  ) {
-    return group(concat([declaration, ifBreak(line, "; "), "end"]));
+  if (isEmptyBodyStmt(node.body[1])) {
+    return group(concat([declaration, hardline, "end"]));
   }
 
   return group(
@@ -58,9 +41,16 @@ function printModule(path, opts, print) {
 }
 
 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([
-      concat(["class << ", path.call(print, "body", 0)]),
+      declaration,
       indent(concat([hardline, path.call(print, "body", 1)])),
       concat([hardline, "end"])
     ])

data/src/ruby/nodes/conditionals.js

@@ -219,7 +219,7 @@ const printConditional = (keyword) => (path, { rubyModifier }, print) => {
 
   // If the body of the conditional is empty, then we explicitly have to use the
   // block form.
-  if (isEmptyStmts(statements) && !statements.body[0].comments) {
+  if (isEmptyStmts(statements)) {
     return concat([
       `${keyword} `,
       align(keyword.length + 1, path.call(print, "body", 0)),

data/src/ruby/nodes/hashes.js

@@ -6,6 +6,7 @@ const {
   join,
   line
 } = require("../../prettier");
+
 const {
   getTrailingComma,
   printEmptyCollection,
@@ -89,6 +90,13 @@ function printAssocNew(path, opts, print) {
   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 {
@@ -125,20 +133,26 @@ function printHash(path, opts, print) {
     return printEmptyCollection(path, opts, "{", "}");
   }
 
-  return group(
-    concat([
-      "{",
-      indent(
-        concat([
-          line,
-          path.call(print, "body", 0),
-          getTrailingComma(opts) ? ifBreak(",", "") : ""
-        ])
-      ),
-      line,
-      "}"
-    ])
-  );
+  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 = {

data/src/ruby/nodes/loops.js

@@ -10,7 +10,7 @@ const {
   softline
 } = require("../../prettier");
 
-const { containsAssignment } = require("../../utils");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
 const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 function printLoop(keyword, modifier) {
@@ -19,17 +19,11 @@ function printLoop(keyword, modifier) {
 
     // If the only statement inside this while loop is a void statement, then we
     // can shorten to just displaying the predicate and then a semicolon.
-    if (
-      stmts.body.length === 1 &&
-      stmts.body[0].type === "void_stmt" &&
-      !stmts.body[0].comments
-    ) {
+    if (isEmptyStmts(stmts)) {
       return group(
         concat([
-          keyword,
-          " ",
-          path.call(print, "body", 0),
-          ifBreak(softline, "; "),
+          group(concat([keyword, " ", path.call(print, "body", 0)])),
+          hardline,
           "end"
         ])
       );

data/src/ruby/nodes/methods.js

@@ -1,8 +1,9 @@
 const { concat, group, hardline, indent, line } = require("../../prettier");
+const { isEmptyBodyStmt } = require("../../utils");
 
 function printMethod(offset) {
   return function printMethodWithOffset(path, opts, print) {
-    const [_name, params, body] = path.getValue().body.slice(offset);
+    const [_name, params, bodystmt] = path.getValue().body.slice(offset);
     const declaration = ["def "];
 
     // In this case, we're printing a method that's defined as a singleton, so
@@ -24,16 +25,8 @@ function printMethod(offset) {
       parens ? ")" : ""
     );
 
-    // If the body is empty, we can replace with a ;
-    const stmts = body.body[0].body;
-
-    if (
-      !body.body.slice(1).some((node) => node) &&
-      stmts.length === 1 &&
-      stmts[0].type === "void_stmt" &&
-      !stmts[0].comments
-    ) {
-      return group(concat(declaration.concat(["; end"])));
+    if (isEmptyBodyStmt(bodystmt)) {
+      return group(concat(declaration.concat("; end")));
     }
 
     return group(

data/src/ruby/nodes/statements.js

@@ -12,15 +12,13 @@ const {
   trim
 } = require("../../prettier");
 
+const { isEmptyStmts } = require("../../utils");
+
 function printBodyStmt(path, opts, print) {
   const [stmts, rescue, elseClause, ensure] = path.getValue().body;
   const parts = [];
 
-  if (
-    stmts.body.length > 1 ||
-    stmts.body[0].type != "void_stmt" ||
-    stmts.body[0].comments
-  ) {
+  if (!isEmptyStmts(stmts)) {
     parts.push(path.call(print, "body", 0));
   }
 

data/src/ruby/parser.rb

@@ -17,7 +17,8 @@ require 'delegate'
 require 'json'
 require 'ripper'
 
-module Prettier; end
+module Prettier
+end
 
 class Prettier::Parser < Ripper
   attr_reader :source, :lines, :scanner_events, :line_counts

data/src/utils.js

@@ -1,6 +1,7 @@
 module.exports = {
   containsAssignment: require("./utils/containsAssignment"),
   getTrailingComma: require("./utils/getTrailingComma"),
+  isEmptyBodyStmt: require("./utils/isEmptyBodyStmt"),
   isEmptyStmts: require("./utils/isEmptyStmts"),
   hasAncestor: require("./utils/hasAncestor"),
   literal: require("./utils/literal"),

data/src/utils/isEmptyBodyStmt.js

@@ -0,0 +1,7 @@
+const isEmptyStmts = require("./isEmptyStmts");
+
+function isEmptyBodyStmt(node) {
+  return isEmptyStmts(node.body[0]) && !node.body.slice(1).some(Boolean);
+}
+
+module.exports = isEmptyBodyStmt;

data/src/utils/isEmptyStmts.js

@@ -1,7 +1,11 @@
-const isEmptyStmts = (node) =>
-  node &&
-  node.type === "stmts" &&
-  node.body.length === 1 &&
-  node.body[0].type === "void_stmt";
+function isEmptyStmts(node) {
+  return (
+    node &&
+    node.type === "stmts" &&
+    node.body.length === 1 &&
+    node.body[0].type === "void_stmt" &&
+    !node.body[0].comments
+  );
+}
 
 module.exports = isEmptyStmts;