prettier 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7cbdd107fd5e3baad2ba213347858ef7eb45789ac6d716924b4df76f0c08eeb
-  data.tar.gz: af6af93bb28ec649ffddc3190f0a61fc9516cef6249f37968ab02e8c3606d80a
+  metadata.gz: '0630719fd8b07b6f6fc180db0c88a5d2d2f0aad3d4cdeef4f14aeba83a87d2f1'
+  data.tar.gz: 925d6a78992ae155cb65ccd336ec34c3cda7538421151d91952a31461718be2b
 SHA512:
-  metadata.gz: 44e9831cbb10a8577f1bc7637775c9edf42765769338a355bb88b96cc6215f826a6ee7098eff1791c522c8d39d46c20a9f77082472704e7b10be04f37699d238
-  data.tar.gz: c2a7fe8fed19e9cefd90a322ab8e2bef45c83d360f07ba9f18d301961ca28e552719f7851fd27c2a9cb68c13d985dcd85555a345aa12ad9d0fe4ac2e10de531d
+  metadata.gz: b8e07ba6fd2839a1c055ec42b08c2f35a92b912a555c227bb644ea91afec560feaa27318df72dfda1023ffbe7a65c446f4ea1ba97ec6202a617d4622abcdbb4b
+  data.tar.gz: 7ef40ccd4d7bc5f3b521070402b1a592706d60cb19edfc3072ab45c9086e954f0f4b801a260e8ccb76efbede4b227ca07e4a6e7c1bd670b230b56b0ff01c3496

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.3] - 2021-01-02
+
+### Changed
+
+- [@lukyth], [@kddeisz] - Ensure if a ternary breaks into an `if..else..end` within a `command_call` node that parentheses are added.
+- [@AlanFoster], [@kddeisz] - Ensure you consume the optional `do` keyword on `while` and `until` loops so that it doesn't confuse the parser.
+- [@AlanFoster], [@kddeisz] - Ensure key-value pairs split on line when the key has a comment attached within a hash.
+- [@AlanFoster], [@kddeisz] - Fix for `for` loops that have multiple index variables.
+- [@AlanFoster], [@kddeisz] - Fix parsing very large files by reducing the size of the JSON output from the parser.
+- [@AlanFoster], [@kddeisz] - Ensure you don't skip parentheses if you're returning a value with the `not` unary operator.
+
 ## [1.2.2] - 2021-01-01
 
 ### Changed
@@ -998,7 +1009,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.2.2...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.2.3...HEAD
+[1.2.3]: https://github.com/prettier/plugin-ruby/compare/v1.2.2...v1.2.3
 [1.2.2]: https://github.com/prettier/plugin-ruby/compare/v1.2.1...v1.2.2
 [1.2.1]: https://github.com/prettier/plugin-ruby/compare/v1.2.0...v1.2.1
 [1.2.0]: https://github.com/prettier/plugin-ruby/compare/v1.1.0...v1.2.0
@@ -1096,6 +1108,7 @@ would previously result in `array[]`, but now prints properly.
 [@kmcq]: https://github.com/kmcq
 [@krachtstefan]: https://github.com/krachtstefan
 [@localhostdotdev]: https://github.com/localhostdotdev
+[@lukyth]: https://github.com/lukyth
 [@marcmaniez]: https://github.com/MarcManiez
 [@masqita]: https://github.com/masqita
 [@matt-wratt]: https://github.com/matt-wratt

data/CONTRIBUTING.md

@@ -22,7 +22,7 @@ In order to get printed, the code goes through a couple of transformations. The
 
 ### Text to AST
 
-When the prettier process first spins up, it examines which files it's going to print and selects an appropriate plugin for each one. Once selected, it runs that plugin's `parse` function, seen [here](src/parser.js). For the case of the Ruby plugin, that entails spawning a Ruby process that runs [parser.rb](src/parser.rb) with the input code preloaded on stdin.
+When the prettier process first spins up, it examines which files it's going to print and selects an appropriate plugin for each one. Once selected, it runs that plugin's `parse` function, seen [here](src/ruby/parser.js). For the case of the Ruby plugin, that entails spawning a Ruby process that runs [parser.rb](src/ruby/parser.rb) with the input code preloaded on stdin.
 
 `parser.rb` will read the text off of stdin and then feed it to a new `Ripper` instance, which is a Ruby standard library recursive-descent parser. Briefly, the way that `Ripper` works is by tokenizing the input and then matching those tokens against a grammar to form s-expressions. To extend `Ripper`, you overwrite the methods that control how those s-expressions are formed, e.g., to modify the s-expression that is formed when `Ripper` encounters a string literal, you would override the `#on_string_literal` method. Below is an example for seeing that in action.
 
@@ -71,7 +71,7 @@ Now that the text has been transformed into an AST that we can work with, `parse
 
 ### AST to Doc
 
-Once prettier has a working AST, it will take it and call the selected plugin's [`printNode` function](src/printer.js), whose purpose is to convert that AST into prettier's intermediate representation called Docs. It does this by handing the print function a `FastPath` object that keeps track of the state of the printing as it goes, and allows accessing various parts of the AST quickly.
+Once prettier has a working AST, it will take it and call the selected plugin's [`printNode` function](src/ruby/printer.js), whose purpose is to convert that AST into prettier's intermediate representation called Docs. It does this by handing the print function a `FastPath` object that keeps track of the state of the printing as it goes, and allows accessing various parts of the AST quickly.
 
 Effectively, it walks the AST in the reverse direction from the way `Ripper` built it (top-down instead of bottom-up). The first node that gets passed into the `print` function is the `program` node as that's always on top. Then it is the `program` node's responsibility to recursively call print on its child nodes as it best sees fit.
 

data/README.md

@@ -120,7 +120,7 @@ The `prettier` executable is now installed and ready for use:
 
 ## Configuration
 
-Below are the options (from [`src/ruby.js`](src/ruby.js)) that `@prettier/plugin-ruby` currently supports:
+Below are the options (from [`src/plugin.js`](src/plugin.js)) that `@prettier/plugin-ruby` currently supports:
 
 | API Option         | CLI Option             | Default | Description                                                                                                                          |
 | ------------------ | ---------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------ |

data/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "prettier plugin for the Ruby programming language",
-  "main": "src/ruby.js",
+  "main": "src/plugin.js",
   "scripts": {
     "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",

data/src/{ruby.js → plugin.js}

@@ -1,5 +1,5 @@
-const printer = require("./printer");
-const parser = require("./parser");
+const printer = require("./ruby/printer");
+const parser = require("./ruby/parser");
 
 /*
  * metadata mostly pulled from linguist and rubocop:

data/src/{embed.js → ruby/embed.js}

@@ -6,9 +6,9 @@ const {
   mapDoc,
   markAsRoot,
   stripTrailingHardline
-} = require("./prettier");
+} = require("../prettier");
 
-const { literalLineNoBreak } = require("./utils");
+const { literalLineNoBreak } = require("../utils");
 
 const parsers = {
   css: "css",

data/src/{nodes → ruby/nodes}/alias.js

@@ -5,7 +5,7 @@ const {
   group,
   hardline,
   line
-} = require("../prettier");
+} = 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

data/src/{nodes → ruby/nodes}/aref.js

@@ -1,4 +1,11 @@
-const { concat, group, indent, join, line, softline } = require("../prettier");
+const {
+  concat,
+  group,
+  indent,
+  join,
+  line,
+  softline
+} = require("../../prettier");
 
 // `aref` nodes are when you're pulling a value out of a collection at a
 // specific index. Put another way, it's any time you're calling the method

data/src/{nodes → ruby/nodes}/args.js

@@ -6,10 +6,10 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
+} = require("../../prettier");
+const { getTrailingComma } = require("../../utils");
 
 const toProc = require("../toProc");
-const { getTrailingComma } = require("../utils");
 
 function printArgParen(path, opts, print) {
   const argsNode = path.getValue().body[0];

data/src/{nodes → ruby/nodes}/arrays.js

@@ -6,9 +6,8 @@ const {
   join,
   line,
   softline
-} = require("../prettier");
-
-const { getTrailingComma, printEmptyCollection } = require("../utils");
+} = 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

data/src/{nodes → ruby/nodes}/assign.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, line } = require("../prettier");
-const { first, skipAssignIndent } = require("../utils");
+const { concat, group, indent, join, line } = require("../../prettier");
+const { skipAssignIndent } = require("../../utils");
 
 function printAssign(path, opts, print) {
   const [_targetNode, valueNode] = path.getValue().body;
@@ -35,9 +35,13 @@ 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: first
+  var_ref: printVarRef
 };

data/src/{nodes → ruby/nodes}/blocks.js

@@ -7,8 +7,8 @@ const {
   join,
   removeLines,
   softline
-} = require("../prettier");
-const { empty, hasAncestor } = require("../utils");
+} = require("../../prettier");
+const { hasAncestor } = require("../../utils");
 
 const printBlock = (braces) => (path, opts, print) => {
   const [variables, statements] = path.getValue().body;
@@ -81,5 +81,5 @@ module.exports = {
   },
   brace_block: printBlock(true),
   do_block: printBlock(false),
-  excessed_comma: empty
+  excessed_comma: () => ""
 };

data/src/{nodes → ruby/nodes}/calls.js

@@ -5,8 +5,8 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
-const { first, makeCall, noIndent } = require("../utils");
+} = require("../../prettier");
+const { makeCall, noIndent } = require("../../utils");
 
 const toProc = require("../toProc");
 
@@ -217,10 +217,14 @@ function printMethodAddBlock(path, opts, print) {
   return concat([callDoc, blockDoc]);
 }
 
+function printCallContainer(path, opts, print) {
+  return path.call(print, "body", 0);
+}
+
 module.exports = {
   call: printCall,
-  fcall: first,
+  fcall: printCallContainer,
   method_add_arg: printMethodAddArg,
   method_add_block: printMethodAddBlock,
-  vcall: first
+  vcall: printCallContainer
 };

data/src/{nodes → ruby/nodes}/case.js

@@ -6,7 +6,7 @@ const {
   hardline,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printCase(path, opts, print) {
   const statement = ["case"];

data/src/{nodes → ruby/nodes}/class.js

@@ -5,7 +5,7 @@ const {
   ifBreak,
   indent,
   line
-} = require("../prettier");
+} = require("../../prettier");
 
 function printClass(path, opts, print) {
   const [_constant, superclass, bodystmt] = path.getValue().body;

data/src/ruby/nodes/commands.js

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

data/src/{nodes → ruby/nodes}/conditionals.js

@@ -7,10 +7,10 @@ const {
   ifBreak,
   indent,
   softline
-} = require("../prettier");
+} = require("../../prettier");
 
-const { containsAssignment, isEmptyStmts } = require("../utils");
-const inlineEnsureParens = require("../utils/inlineEnsureParens");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
+const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([

data/src/{nodes → ruby/nodes}/constants.js

@@ -1,5 +1,5 @@
-const { concat, group, indent, join, softline } = require("../prettier");
-const { makeCall } = require("../utils");
+const { concat, group, indent, join, softline } = require("../../prettier");
+const { makeCall } = require("../../utils");
 
 function printConstPath(path, opts, print) {
   return join("::", path.map(print, "body"));

data/src/{nodes → ruby/nodes}/flow.js

@@ -1,5 +1,5 @@
-const { concat, join } = require("../prettier");
-const { literal } = require("../utils");
+const { concat, join } = require("../../prettier");
+const { literal } = require("../../utils");
 
 const nodeDive = (node, steps) => {
   let current = node;

data/src/{nodes → ruby/nodes}/hashes.js

@@ -1,11 +1,16 @@
-const { concat, group, ifBreak, indent, join, line } = require("../prettier");
-
+const {
+  concat,
+  group,
+  ifBreak,
+  indent,
+  join,
+  line
+} = require("../../prettier");
 const {
   getTrailingComma,
-  prefix,
   printEmptyCollection,
   skipAssignIndent
-} = require("../utils");
+} = require("../../utils");
 
 // When attempting to convert a hash rocket into a hash label, you need to take
 // care because only certain patterns are allowed. Ruby source says that they
@@ -49,8 +54,20 @@ function printHashKeyLabel(path, print) {
       return print(path);
     case "symbol_literal":
       return concat([path.call(print, "body", 0), ":"]);
-    case "dyna_symbol":
-      return concat(print(path).parts.slice(1).concat(":"));
+    case "dyna_symbol": {
+      const { parts } = print(path);
+
+      // We're going to slice off the starting colon character so that we can
+      // move it to the end. If there are comments, then we're going to go
+      // further into the printed doc nodes.
+      if (parts[0] === ":") {
+        parts.splice(0, 1);
+      } else {
+        parts[1].parts.splice(0, 1);
+      }
+
+      return concat(parts.concat(":"));
+    }
   }
 }
 
@@ -66,20 +83,25 @@ function printHashKeyRocket(path, print) {
 }
 
 function printAssocNew(path, opts, print) {
+  const [keyNode, valueNode] = path.getValue().body;
   const { keyPrinter } = path.getParentNode();
 
   const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
   const valueDoc = path.call(print, "body", 1);
 
-  if (skipAssignIndent(path.getValue().body[1])) {
-    parts.push(" ", valueDoc);
-  } else {
+  if (!skipAssignIndent(valueNode) || keyNode.comments) {
     parts.push(indent(concat([line, valueDoc])));
+  } else {
+    parts.push(" ", valueDoc);
   }
 
   return group(concat(parts));
 }
 
+function printAssocSplat(path, opts, print) {
+  return concat(["**", path.call(print, "body", 0)]);
+}
+
 function printHashContents(path, opts, print) {
   const node = path.getValue();
 
@@ -121,7 +143,7 @@ function printHash(path, opts, print) {
 
 module.exports = {
   assoc_new: printAssocNew,
-  assoc_splat: prefix("**"),
+  assoc_splat: printAssocSplat,
   assoclist_from_args: printHashContents,
   bare_assoc_hash: printHashContents,
   hash: printHash