prettier 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0630719fd8b07b6f6fc180db0c88a5d2d2f0aad3d4cdeef4f14aeba83a87d2f1'
-  data.tar.gz: 925d6a78992ae155cb65ccd336ec34c3cda7538421151d91952a31461718be2b
+  metadata.gz: 3c6028bdf8198f8cfdd43bdb8d8b577e7a3bae5aaa108af45e0ee065d0b373b3
+  data.tar.gz: 90847afd8a74ba465b5a1bcc3dcfdc146ce57c01df77f1e3fa8c04a8b254c870
 SHA512:
-  metadata.gz: b8e07ba6fd2839a1c055ec42b08c2f35a92b912a555c227bb644ea91afec560feaa27318df72dfda1023ffbe7a65c446f4ea1ba97ec6202a617d4622abcdbb4b
-  data.tar.gz: 7ef40ccd4d7bc5f3b521070402b1a592706d60cb19edfc3072ab45c9086e954f0f4b801a260e8ccb76efbede4b227ca07e4a6e7c1bd670b230b56b0ff01c3496
+  metadata.gz: d99e6fefc109919be2317805e2462c0f38d2cfc7b005df3b200ea9b29ff2ac6f4438617580df94ae58c95a0df21717d87025b9ed6301e35c62fd1b84be63f321
+  data.tar.gz: 97353a101ef9256d63035e8838c32435816a84f735dc9aaf40a6f62b69e699249acbb2cc51ea4075802f848368712fca11ba54d8b5203392050199b1cc1f5f13

data/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.2.4] - 2021-01-03
+
+### Added
+
+- [@andyw8] - Explain usage with Rubocop, as well as shipping a rubocop.yml config.
+
+### Changed
+
+- [@kddeisz] - Reduce JSON size passing from Ruby process to node process by changing `char_start` -> `sc`, `char_end` -> `ec`, `start` -> `sl`, `end` -> `el`.
+- [@kddeisz] - Up the max buffer size between the Ruby and node processes to 15K.
+
 ## [1.2.3] - 2021-01-02
 
 ### Changed

data/README.md

@@ -149,6 +149,19 @@ Or, they can be passed to `prettier` as arguments:
 prettier --ruby-single-quote false --write '**/*.rb'
 ```
 
+### Usage with RuboCop
+
+RuboCop and Prettier for Ruby serve different purposes, but there is overlap
+with some of RuboCop's functionality.
+
+Prettier provides a RuboCop configuration fle to disable the rules which clash.
+To enable, add the following config at the top of your project's `.rubocop.yml`:
+
+```yaml
+inherit_gem:
+  prettier: rubocop.yml
+```
+
 ## Contributing
 
 Check out our [contributing guide](CONTRIBUTING.md). Bug reports and pull requests are welcome on GitHub at https://github.com/prettier/plugin-ruby.

data/package.json

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

data/rubocop.yml

@@ -0,0 +1,26 @@
+# Disabling all Layout/* rules, as they're unnecessary when the user is using
+# prettier to handle all of the formatting.
+
+Layout:
+  Enabled: false
+
+# Disabling all of the following options because they could conflict with a
+# prettier configuration setting.
+
+Style/MultilineIfModifier: # rubyModifier
+  Enabled: false
+
+Style/SymbolArray: # rubyArrayLiteral
+  Enabled: false
+
+Style/WordArray: # rubyArrayLiteral
+  Enabled: false
+
+Style/TrailingCommaInArguments: # trailingComma
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral: # trailingComma
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral: # trailingComma
+  Enabled: false

data/src/prettier.js

@@ -1,6 +1,7 @@
 // If `RBPRETTIER` is set, then this is being run from the `Prettier::run` ruby
 // method. In that case, we need to pull `prettier` from the node_modules
 // directly, as it's been shipped with the gem.
+/* istanbul ignore next */
 const source = process.env.RBPRETTIER ? "../node_modules/prettier" : "prettier";
 
 const prettier = require(source);

data/src/ruby/embed.js

@@ -20,6 +20,10 @@ const parsers = {
   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 */
 const replaceNewlines = (doc) =>
   mapDoc(doc, (currentDoc) =>
     typeof currentDoc === "string" && currentDoc.includes("\n")

data/src/ruby/nodes/blocks.js

@@ -10,76 +10,81 @@ const {
 } = require("../../prettier");
 const { hasAncestor } = require("../../utils");
 
-const printBlock = (braces) => (path, opts, print) => {
-  const [variables, statements] = path.getValue().body;
-  const stmts =
-    statements.type === "stmts" ? statements.body : statements.body[0].body;
+function printBlockVar(path, opts, print) {
+  const parts = ["|", removeLines(path.call(print, "body", 0))];
 
-  let doBlockBody = "";
-  if (
-    stmts.length !== 1 ||
-    stmts[0].type !== "void_stmt" ||
-    stmts[0].comments
-  ) {
-    doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
+  // 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)));
   }
 
-  // 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"]);
+  parts.push("| ");
+  return concat(parts);
+}
 
-  const doBlock = concat([
-    useBraces ? " {" : " do",
-    variables ? concat([" ", path.call(print, "body", 0)]) : "",
-    doBlockBody,
-    concat([softline, useBraces ? "}" : "end"])
-  ]);
+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;
 
-  // 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]);
-  }
+    let doBlockBody = "";
+    if (
+      stmts.length !== 1 ||
+      stmts[0].type !== "void_stmt" ||
+      stmts[0].comments
+    ) {
+      doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
+    }
 
-  // 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(path.getParentNode().body[0].type)) {
-    return concat([breakParent, doBlock]);
-  }
+    // 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 hasBody = stmts.some(({ type }) => type !== "void_stmt");
-  const braceBlock = concat([
-    " {",
-    hasBody || variables ? " " : "",
-    variables ? path.call(print, "body", 0) : "",
-    path.call(print, "body", 1),
-    hasBody ? " " : "",
-    "}"
-  ]);
+    const doBlock = concat([
+      useBraces ? " {" : " do",
+      variables ? concat([" ", path.call(print, "body", 0)]) : "",
+      doBlockBody,
+      concat([softline, useBraces ? "}" : "end"])
+    ]);
 
-  return group(ifBreak(doBlock, braceBlock));
-};
+    // 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]);
+    }
 
-module.exports = {
-  block_var: (path, opts, print) => {
-    const parts = ["|", removeLines(path.call(print, "body", 0))];
+    const blockReceiver = path.getParentNode().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)));
+    // 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]);
     }
 
-    parts.push("| ");
-    return concat(parts);
-  },
+    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),
-  excessed_comma: () => ""
+  do_block: printBlock(false)
 };

data/src/ruby/nodes/hooks.js

@@ -1,5 +1,4 @@
 const { concat, group, indent, line } = require("../../prettier");
-const { isEmptyStmts } = require("../../utils");
 
 // The `BEGIN` and `END` keywords are used to hook into the Ruby process. Any
 // `BEGIN` blocks are executed right when the process starts up, and the `END`
@@ -17,24 +16,15 @@ const { isEmptyStmts } = require("../../utils");
 // nodes contain one child which is a `stmts` node.
 function printHook(name) {
   return function printHookWithName(path, opts, print) {
-    const stmtsNode = path.getValue().body[1];
-    const printedStmts = path.call(print, "body", 1);
-
-    const parts = [
-      name,
-      " ",
-      path.call(print, "body", 0),
-      indent(concat([line, printedStmts])),
-      concat([line, "}"])
-    ];
-
-    // If there are no statements but there are comments, then we want to skip
-    // printing the newline so that we don't end up with multiple spaces.
-    if (isEmptyStmts(stmtsNode) && stmtsNode.comments) {
-      parts[1] = indent(printedStmts);
-    }
-
-    return group(concat(parts));
+    return group(
+      concat([
+        name,
+        " ",
+        path.call(print, "body", 0),
+        indent(concat([line, path.call(print, "body", 1)])),
+        concat([line, "}"])
+      ])
+    );
   };
 }
 

data/src/ruby/nodes/methods.js

@@ -47,15 +47,13 @@ function printMethod(offset) {
 }
 
 function printSingleLineMethod(path, opts, print) {
-  let paramsNode = path.getValue().body[1];
+  let parensNode = path.getValue().body[1];
   let paramsDoc = "";
 
-  if (paramsNode) {
-    if (paramsNode.body[0].type === "params") {
-      paramsNode = paramsNode.body[0];
-    }
+  if (parensNode) {
+    const paramsNode = parensNode.body[0];
 
-    if (paramsNode.type === "params" && paramsNode.body.some((type) => type)) {
+    if (paramsNode.body.some((type) => type)) {
       paramsDoc = path.call(print, "body", 1);
     }
   }

data/src/ruby/nodes/params.js

@@ -29,18 +29,22 @@ function printParams(path, opts, print) {
   let parts = [];
 
   if (reqs) {
-    parts = parts.concat(path.map(print, "body", 0));
+    path.each(
+      (reqPath) => {
+        // For some very strange reason, if you have a comment attached to a
+        // rest_param, it shows up here in the list of required params.
+        if (reqPath.getValue().type !== "rest_param") {
+          parts.push(print(reqPath));
+        }
+      },
+      "body",
+      0
+    );
   }
 
   if (optls) {
     parts = parts.concat(
-      optls.map((_, index) =>
-        concat([
-          path.call(print, "body", 1, index, 0),
-          " = ",
-          path.call(print, "body", 1, index, 1)
-        ])
-      )
+      path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1)
     );
   }
 
@@ -54,12 +58,16 @@ function printParams(path, opts, print) {
 
   if (kwargs) {
     parts = parts.concat(
-      kwargs.map(([, value], index) => {
-        if (!value) {
-          return path.call(print, "body", 4, index, 0);
-        }
-        return group(join(" ", path.map(print, "body", 4, index)));
-      })
+      path.map(
+        (kwargPath) => {
+          if (!kwargPath.getValue()[1]) {
+            return kwargPath.call(print, 0);
+          }
+          return group(join(" ", kwargPath.map(print)));
+        },
+        "body",
+        4
+      )
     );
   }
 

data/src/ruby/nodes/patterns.js

@@ -1,4 +1,5 @@
 const {
+  align,
   concat,
   group,
   hardline,
@@ -74,7 +75,7 @@ function printHshPtn(path, opts, print) {
   const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
   let args = [];
 
-  if (keyValuePairs) {
+  if (keyValuePairs.length > 0) {
     const printPair = (pairPath) => {
       const parts = [pairPath.call(print, 0)];
 
@@ -116,10 +117,13 @@ function printHshPtn(path, opts, print) {
 function printIn(path, opts, print) {
   const parts = [
     "in ",
-    path.call(
-      (valuePath) => printPatternArg(valuePath, opts, print),
-      "body",
-      0
+    align(
+      "in ".length,
+      path.call(
+        (valuePath) => printPatternArg(valuePath, opts, print),
+        "body",
+        0
+      )
     ),
     indent(concat([hardline, path.call(print, "body", 1)]))
   ];

data/src/ruby/nodes/return.js

@@ -41,10 +41,6 @@ const printReturn = (path, opts, print) => {
   let args = path.getValue().body[0].body[0];
   let steps = ["body", 0, "body", 0];
 
-  if (!args) {
-    return "return";
-  }
-
   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

data/src/ruby/nodes/statements.js

@@ -30,6 +30,7 @@ function printBodyStmt(path, opts, print) {
 
   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)
@@ -69,11 +70,7 @@ function printParen(path, opts, print) {
   }
 
   return group(
-    concat([
-      "(",
-      indent(concat([softline, contentDoc])),
-      concat([softline, ")"])
-    ])
+    concat(["(", indent(concat([softline, contentDoc])), softline, ")"])
   );
 }
 
@@ -123,12 +120,12 @@ module.exports = {
       if (lineNo === null) {
         parts.push(printed);
       } else if (
-        stmt.start - lineNo > 1 ||
+        stmt.sl - lineNo > 1 ||
         [stmt.type, stmts[index - 1].type].includes("access_ctrl")
       ) {
         parts.push(hardline, hardline, printed);
       } else if (
-        stmt.start !== lineNo ||
+        stmt.sl !== lineNo ||
         path.getParentNode().type !== "string_embexpr"
       ) {
         parts.push(hardline, printed);
@@ -136,7 +133,7 @@ module.exports = {
         parts.push("; ", printed);
       }
 
-      lineNo = stmt.end;
+      lineNo = stmt.el;
     });
 
     return concat(parts);