prettier 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 628031f901d9500c43e16890affeb303afcd9fc6241a5adde35ea59e2e8848da
-  data.tar.gz: 3e138dd11805ad5de42ebcd3d25541b1b897f183492fd488e91ca906ba51d784
+  metadata.gz: c098ce338da8191c1a6a46d6817aa38997aa0fbc318dbc045ae191600654d1a0
+  data.tar.gz: d75cc10cf135ffbcbd35f2bb0404dc07b5f645024d57fefdb598cbe99d54bcb1
 SHA512:
-  metadata.gz: 7b92c23628247bc53f6ebe5b39f4b7b961a38c0bccc2eb6ec701b52f8be8df7d507ec6dab28b3f48b0600cdafbc9ab51fcf52001c726535f191dab67a1d301aa
-  data.tar.gz: 0335f2171298ebe46ca5c960a252ec49abc315bfc0438bb75a28ff4204c5dda340532c93af936b27d861ab867308f7f149c3b0eebf26cdd8d3475ba133e52854
+  metadata.gz: 7a4c41e7c19215101dee83152d3fd0dab79ee4d43c485254e4f65d963ffbab55e8b68cc5f6a670375552caba832071bfcf609668249139edd81d89a7960274c1
+  data.tar.gz: 655bd92259ffb6346cfd1120b8533dfb0ccf37bc78e7d9ed7041fc14c915abdbe7413a451f9bc9061153721110670603e4a4b5fbc638497033b5c0305a17144b

data/CHANGELOG.md

@@ -6,6 +6,21 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+# [0.22.0] - 2020-12-08
+
+### Changed
+
+- [@flyerhzm] - Print method chains by one indentation.
+- [@mmcnl], [@kddeisz] - Handle heredocs and blocks being passed to the same method.
+- [@johncsnyder], [@kddeisz] - Ensure correct formatting when breaking up conditionals with `inlineConditionals: false`.
+- [@Rsullivan00] - Ensure that when ternaries as command arguments get broken into multiple lines we add the necessary parentheses.
+- [@jbielick] - Maintain parse order during if/unless modifier expressions
+- [@flyerhzm] - Slight prettifying of wrapped args if doc length is under a certain value.
+- [@github0013], [@kddeisz] - Ensure `not` keeps parentheses if they are being used.
+- [@jbielick] - Print heredocs consistently.
+- [@kddeisz] - Completely revamp the way we handle comments.
+- [@kddeisz] - Support `hshptn` and the remaining missing pattern matching syntax.
+
 ## [0.21.0] - 2020-12-02
 
 ### Changed
@@ -862,7 +877,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v0.21.0...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v0.22.0...HEAD
+[0.22.0]: https://github.com/prettier/plugin-ruby/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/prettier/plugin-ruby/compare/v0.20.1...v0.21.0
 [0.20.1]: https://github.com/prettier/plugin-ruby/compare/v0.20.0...v0.20.1
 [0.20.0]: https://github.com/prettier/plugin-ruby/compare/v0.19.1...v0.20.0
@@ -964,3 +980,4 @@ would previously result in `array[]`, but now prints properly.
 [@steobrien]: https://github.com/steobrien
 [@jbielick]: https://github.com/jbielick
 [@coiti]: https://github.com/coiti
+[@johncsnyder]: https://github.com/johncsnyder

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/parse.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/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.
 
 `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 [`print` function](src/print.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/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.
 
@@ -168,8 +168,8 @@ While developing, we've built a couple of small utilities for debugging the `pre
 
 - `bin/lex [file|source]` - outputs the tokens as ripper sees them
 - `bin/sexp [file|source]` - outputs the AST that ripper builds before it gets passed back to `prettier`
+- `bin/pragma [file]` - runs the `hasPragma` function against the given input file
 - `bin/print [file|source]` - outputs the printed source of a Ruby file after running it through `prettier`
-- `bin/has-pragma [file]` - runs the `hasPragma` function against the given input file
 
 ## Testing
 

data/README.md

@@ -224,6 +224,10 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
     <td align="center"><a href="https://joshbielick.com/"><img src="https://avatars2.githubusercontent.com/u/1413330?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Josh Bielick</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Ajbielick" title="Bug reports">🐛</a> <a href="https://github.com/prettier/plugin-ruby/commits?author=jbielick" title="Code">💻</a></td>
     <td align="center"><a href="https://github.com/coiti"><img src="https://avatars3.githubusercontent.com/u/27384706?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Román Coitiño</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Acoiti" title="Bug reports">🐛</a></td>
   </tr>
+  <tr>
+    <td align="center"><a href="https://github.com/mmcnl"><img src="https://avatars2.githubusercontent.com/u/1498727?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Matt McNeil</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Ammcnl" title="Bug reports">🐛</a></td>
+    <td align="center"><a href="https://github.com/johncsnyder"><img src="https://avatars2.githubusercontent.com/u/9882099?v=4?s=100" width="100px;" alt=""/><br /><sub><b>John Snyder</b></sub></a><br /><a href="https://github.com/prettier/plugin-ruby/issues?q=author%3Ajohncsnyder" title="Bug reports">🐛</a></td>
+  </tr>
 </table>
 
 <!-- markdownlint-restore -->

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
@@ -24,8 +24,8 @@
   "devDependencies": {
     "all-contributors-cli": "^6.14.1",
     "eslint": "^7.8.1",
-    "eslint-config-prettier": "^6.10.1",
-    "husky": "^4.2.5",
+    "eslint-config-prettier": "^7.0.0",
+    "husky": "^5.0.4",
     "jest": "^26.0.0",
     "pretty-quick": "^3.0.0"
   },

data/src/embed.js

@@ -1,12 +1,15 @@
 const {
   concat,
+  group,
   indent,
-  literalline,
+  lineSuffix,
   mapDoc,
   markAsRoot,
   stripTrailingHardline
 } = require("./prettier");
 
+const { literalLineNoBreak } = require("./utils");
+
 const parsers = {
   css: "css",
   javascript: "babel",
@@ -23,7 +26,7 @@ const replaceNewlines = (doc) =>
       ? concat(
           currentDoc
             .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literalline))
+            .map((v, i) => (i % 2 === 0 ? v : literalLineNoBreak))
         )
       : currentDoc
   );
@@ -53,19 +56,31 @@ const embed = (path, _print, textToDoc, _opts) => {
   // into the embedded parser. Get back the doc node.
   const content = body.map((part) => part.body).join("");
   const formatted = concat([
-    literalline,
+    literalLineNoBreak,
     replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
   ]);
 
   // If we're using a squiggly heredoc, then we can properly handle indentation
   // ourselves.
   if (beging[2] === "~") {
-    return concat([beging, indent(markAsRoot(formatted)), literalline, ending]);
+    return concat([
+      beging,
+      lineSuffix(
+        group(
+          concat([indent(markAsRoot(formatted)), literalLineNoBreak, ending])
+        )
+      )
+    ]);
   }
 
   // Otherwise, we need to just assume it's formatted correctly and return the
   // content as it is.
-  return markAsRoot(concat([beging, formatted, literalline, ending]));
+  return markAsRoot(
+    concat([
+      beging,
+      lineSuffix(group(concat([formatted, literalLineNoBreak, ending])))
+    ])
+  );
 };
 
 module.exports = embed;

data/src/nodes.js

@@ -8,11 +8,13 @@ module.exports = Object.assign(
   require("./nodes/blocks"),
   require("./nodes/calls"),
   require("./nodes/case"),
+  require("./nodes/class"),
   require("./nodes/commands"),
   require("./nodes/conditionals"),
   require("./nodes/constants"),
   require("./nodes/flow"),
   require("./nodes/hashes"),
+  require("./nodes/heredocs"),
   require("./nodes/hooks"),
   require("./nodes/ints"),
   require("./nodes/lambdas"),
@@ -25,7 +27,8 @@ module.exports = Object.assign(
   require("./nodes/regexp"),
   require("./nodes/rescue"),
   require("./nodes/return"),
-  require("./nodes/scopes"),
   require("./nodes/statements"),
-  require("./nodes/strings")
+  require("./nodes/strings"),
+  require("./nodes/super"),
+  require("./nodes/undef")
 );

data/src/nodes/alias.js

@@ -7,49 +7,47 @@ const {
   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, _opts, print, argIndex) {
+// 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" && node.body[0].type === "symbol") {
+  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].body[0], comment);
+        addTrailingComment(node.body[0], comment);
       });
     }
 
-    return path.call(print, "body", argIndex, "body", 0, "body", 0);
+    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`.
- */
+// 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 ";
 
@@ -57,14 +55,14 @@ function printAlias(path, opts, print) {
     // 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, opts, print, 1)
+    printAliasArgument(path, print, 1)
   ]);
 
   return group(
     concat([
       keyword,
-      printAliasArgument(path, opts, print, 0),
-      group(align(keyword, rightSide))
+      printAliasArgument(path, print, 0),
+      group(align(keyword.length, rightSide))
     ])
   );
 }

data/src/nodes/aref.js

@@ -1,17 +1,17 @@
 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
- * `#[]`.
- *
- * The nodes usually contains two children, details below in the
- * `printArefField` function. In some cases, you don't necessarily have the
- * second child node, because you can call procs with a pretty esoteric syntax.
- * In the following example, you wouldn't have a second child, and `"foo"` would
- * be the first child.
- *
- *     foo[]
- */
+// `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
+// `#[]`.
+//
+// The nodes usually contains two children, details below in the
+// `printArefField` function. In some cases, you don't necessarily have the
+// second child node, because you can call procs with a pretty esoteric syntax.
+// In the following example, you wouldn't have a second child, and `"foo"` would
+// be the first child.
+//
+//     foo[]
+//
 function printAref(path, opts, print) {
   const indexNode = path.getValue().body[1];
 
@@ -22,20 +22,20 @@ function printAref(path, opts, print) {
   return printArefField(path, opts, print);
 }
 
-/* `aref_field` nodes are for assigning values into collections at specific
- * indices. Put another way, it's any time you're calling the method `#[]=`.
- * The `aref_field` node itself is just the left side of the assignment, and
- * they're always wrapped in `assign` nodes.
- *
- * The nodes always contain two children, the name of the array (usually a
- * `vcall` node and the index (usually an `args_add_block` node). The
- * `args_add_block` is one of a couple nodes that has special handling where its
- * printed form is actually an array to make joining easier.
- *
- * So in the following example, `"foo"` is the array and `["bar"]` is the index.
- *
- *     foo[bar] = baz
- */
+// `aref_field` nodes are for assigning values into collections at specific
+// indices. Put another way, it's any time you're calling the method `#[]=`.
+// The `aref_field` node itself is just the left side of the assignment, and
+// they're always wrapped in `assign` nodes.
+//
+// The nodes always contain two children, the name of the array (usually a
+// `vcall` node and the index (usually an `args_add_block` node). The
+// `args_add_block` is one of a couple nodes that has special handling where its
+// printed form is actually an array to make joining easier.
+//
+// So in the following example, `"foo"` is the array and `["bar"]` is the index.
+//
+//     foo[bar] = baz
+//
 function printArefField(path, opts, print) {
   const [printedArray, printedIndex] = path.map(print, "body");
 

data/src/nodes/args.js

@@ -9,50 +9,78 @@ const {
 } = require("../prettier");
 
 const toProc = require("../toProc");
-const { makeArgs } = require("../utils");
+const { docLength } = require("../utils");
 
 module.exports = {
   arg_paren: (path, opts, print) => {
-    if (path.getValue().body[0] === null) {
+    const argsNode = path.getValue().body[0];
+    const { addTrailingCommas } = opts;
+
+    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 (path.getValue().body[0].type === "args_forward") {
-      return "(...)";
+    if (argsNode.type === "args_forward") {
+      return group(
+        concat([
+          "(",
+          indent(concat([softline, path.call(print, "body", 0)])),
+          softline,
+          ")"
+        ])
+      );
     }
 
-    const { addTrailingCommas } = opts;
-    const { args, heredocs } = makeArgs(path, opts, print, 0);
-
-    const argsNode = path.getValue().body[0];
+    const args = path.call(print, "body", 0);
     const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
 
-    if (heredocs.length > 1) {
-      return concat(["(", join(", ", args), ")"].concat(heredocs));
-    }
+    // These are the docs representing the actual arguments, without any
+    // parentheses or surrounding lines yet added.
+    let argsDocs = [
+      join(concat([",", line]), args),
+      addTrailingCommas && !hasBlock ? ifBreak(",", "") : ""
+    ];
 
-    const parenDoc = group(
-      concat([
-        "(",
-        indent(
-          concat([
-            softline,
-            join(concat([",", line]), args),
-            addTrailingCommas && !hasBlock ? ifBreak(",", "") : ""
-          ])
-        ),
-        concat([softline, ")"])
-      ])
-    );
-
-    if (heredocs.length === 1) {
-      return group(concat([parenDoc].concat(heredocs)));
+    // Here we're going to make a determination on whether or not we should put
+    // a newline before the first argument. In some cases this makes the
+    // appearance a little better. For example, instead of taking this input:
+    //
+    //     foo(arg1, arg2).bar(arg1, arg2).baz(arg1)
+    //
+    // and transforming it into this:
+    //
+    //     foo(arg1, arg2).bar(arg1, arg2).baz(
+    //       arg1
+    //     )
+    //
+    // it instead gets transformed into this:
+    //
+    //     foo(arg1, arg2).bar(arg1, arg2)
+    //       .baz(arg1)
+    //
+    const maxDocLength = 15;
+    const firstArgDoc = args[0];
+
+    // prettier-ignore
+    const shouldWrapLine =
+      (args.reduce((sum, arg) => sum + docLength(arg), 0) > maxDocLength) ||
+      (args.length == 1 && firstArgDoc.type === "group" && docLength(firstArgDoc) > maxDocLength) ||
+      (firstArgDoc.type === "concat" && firstArgDoc.parts.some((part) => part.type === "group"));
+
+    // Here we're going to get all of the docs representing the doc that's
+    // inside the parentheses.
+    if (shouldWrapLine) {
+      argsDocs = [indent(concat([softline].concat(argsDocs))), softline];
+    } else {
+      argsDocs = [indent(concat(argsDocs))];
     }
 
-    return parenDoc;
+    // Now here we return a doc that represents the whole grouped expression,
+    // including the surrouding parentheses.
+    return group(concat(["("].concat(argsDocs).concat(")")));
   },
   args: (path, opts, print) => {
     const args = path.map(print, "body");