prettier 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8393d82622bcce83298aa8e2833b37bccf9742b0a67e81cd3b730e57e6795b8
-  data.tar.gz: a66af4efc73854f143e0faa288fdde112bf87ba45364af3efd862a179734453c
+  metadata.gz: 34ffeeada2b06900ec6759f31a42ca387c8748a6a22843a1792fd906bfb4ffda
+  data.tar.gz: ddbceb38e8263f881fd12f66560615db880cf7870f0cb926671c2da656aad6f8
 SHA512:
-  metadata.gz: f780174b5b038bfd9583c637caefff23e442f4aef626e9e33769811c15afd7c267bb78f20c4eb223ab4b50f3c0b6664123c6ce00d997ff0a571b0d57228f5070
-  data.tar.gz: bdfbd3f42b4db020059b511b3176ee7b5393a5a008136dd06a584c26df69afbcfe7d937e6151e22029858d71bad68e8c68eb07241e67771debd802cf733c282d
+  metadata.gz: 300acaf432b28f15d5b7690effbe7ca8fff778af699c5f79d0872c15f3241ec9be2e8fd83f86a9e65e6807cd152504b78d79760b30926c418bc7358d5d9f7524
+  data.tar.gz: a7d658200446e7dde838d07b502303fa30e168e800f3053e48e6cf05940fbb92892d0eaca9c48304a48b13d6c94dce09019bb7a2c18acc18c48b3c241d4d4637

data/CHANGELOG.md

@@ -6,6 +6,27 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [2.1.0] - 2022-04-04
+
+### Added
+
+- [#1065](https://github.com/prettier/plugin-ruby/issues/1065) - langalex, kddnewton - The ability to set the `PRETTIER_RUBY_TIMEOUT_MS` environment variable to control how long to wait for the parser server to spin up.
+- [#1173](https://github.com/prettier/plugin-ruby/pull/1173) - dleavitt - Support for RBS 2.x on Ruby 3.1.
+
+### Changed
+
+- [#1028](https://github.com/prettier/plugin-ruby/issues/1028) - levymetal, kddnewton - Fix up some nested formatting with very complicated RSpec assertions.
+- [#1035](https://github.com/prettier/plugin-ruby/issues/1035) - qcn, kddnewton - Ensure we don't try to print `return` incorrectly when multiple statements are contained within parentheses.
+- [#1048](https://github.com/prettier/plugin-ruby/pull/1048) - kddnewton - Completely refactor the Ruby parser to use classes instead of hashes. Also remove a lot of the `body` keys are replace them with actual names.
+- [#1042](https://github.com/prettier/plugin-ruby/issues/1042) - JoshuaKGoldberg, kddnewton - Ensure blocks are printed correctly when there are trailing comments on the `do` keyword.
+- [#1134](https://github.com/prettier/plugin-ruby/pull/1134) - mhssmnn - Fix piping for STDIN to the gem process.
+- [#1167](https://github.com/prettier/plugin-ruby/pull/1167) - dleavitt - More consistent assignment indentation.
+- [#1074](https://github.com/prettier/plugin-ruby/issues/1074) - wagenet, kddnewton - Fix up `return` when nodes return arrays of docs.
+
+### Removed
+
+- [#1048](https://github.com/prettier/plugin-ruby/pull/1048) - kddnewton - Drop support for Ruby 2.5.
+
 ## [2.0.0] - 2021-10-28
 
 ### Changed
@@ -1187,7 +1208,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v2.0.0...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v2.1.0...HEAD
+[2.1.0]: https://github.com/prettier/plugin-ruby/compare/v2.0.0...v2.1.0
 [2.0.0]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc4...v2.0.0
 [2.0.0-rc4]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc3...v2.0.0-rc4
 [2.0.0-rc3]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc2...v2.0.0-rc3

data/dist/haml/parser.rb

@@ -44,6 +44,12 @@ class Haml::Parser::ParseNode
         if hash
           # Explicitly not using Enumerable#to_h here to support Ruby 2.5
           hash.each_with_object({}) do |(key, value), response|
+            # For attributes that starts with @, wrap the attribute in quotes
+            # For other attributes, remove the quotes
+            # AlpineJS uses @-attributes
+            # {'type': 'submit'} => {type: 'submit'}
+            # {'@click': 'open'} => {'@click': 'open'}
+            key = "\'#{key}\'" if key.start_with?('@')
             response[key] = parse_value(value, level + 1)
           end
         else

data/dist/parser/getInfo.js

@@ -1,12 +1,19 @@
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { existsSync, readFileSync } = require("fs");
 
+// This is how long to wait for the parser to spin up. For the most part, 5
+// seconds is plenty of time. But in some environments, it may be necessary to
+// increase this value.
+const timeoutMs = parseInt(process.env.PRETTIER_RUBY_TIMEOUT_MS || "5000", 10);
+
 const filepath = process.argv[process.argv.length - 1];
 
 const timeout = setTimeout(() => {
   clearInterval(interval);
-  throw new Error("Failed to get information from parse server in time.");
-}, 5000);
+  throw new Error(`Failed to get information from parse server in time. If this
+    happens repeatedly, try increasing the PRETTIER_RUBY_TIMEOUT_MS environment
+    variable beyond 5000.`);
+}, timeoutMs);
 
 const interval = setInterval(() => {
   if (existsSync(filepath)) {

data/dist/parser/server.rb

@@ -6,6 +6,10 @@ require 'json'
 require 'fileutils'
 require 'open3'
 
+# Ensure the parent module is defined before requiring the parsers.
+module Prettier
+end
+
 require_relative '../ruby/parser'
 require_relative '../rbs/parser'
 require_relative '../haml/parser'
@@ -72,7 +76,7 @@ listener =
           when 'ping'
             'pong'
           when 'ruby'
-            Prettier::Parser.parse(source)
+            SyntaxTree.parse(source)
           when 'rbs'
             Prettier::RBSParser.parse(source)
           when 'haml'
@@ -84,7 +88,7 @@ listener =
         else
           socket.write('{ "error": true }')
         end
-      rescue Prettier::Parser::ParserError => error
+      rescue SyntaxTree::ParseError => error
         loc = { start: { line: error.lineno, column: error.column } }
         socket.write(JSON.fast_generate(error: error.message, loc: loc))
       rescue StandardError => error

data/dist/rbs/parser.rb

@@ -19,6 +19,17 @@ rescue LoadError
   return
 end
 
+# This was removed at some point, so we need to support both versions.
+RBS::KEYWORD_RAW =
+  if RBS::Parser.const_defined?(:KEYWORDS_RE)
+    RBS::Parser::KEYWORDS_RE
+  else
+    RBS::Parser::KEYWORDS.keys.join('|')
+  end
+
+# This enforces that the full matched string is a keyword.
+RBS::KEYWORD_FULL = /\A#{RBS::KEYWORD_RAW}\z/
+
 # Monkey-patch this so that we can get the character positions.
 class RBS::Location
   def to_json(*args)
@@ -40,7 +51,12 @@ end
 # Monkey-patch this so that we get whether or not it needs to be escaped.
 class RBS::Types::Function::Param
   def to_json(*a)
-    escaped = name && /\A#{RBS::Parser::KEYWORDS_RE}\z/.match?(name)
+    escaped = name && RBS::KEYWORD_FULL.match?(name)
+
+    # More modern versions of RBS just include the ` in the name so there's no
+    # need to escape it further.
+    escaped = false if name.to_s.start_with?('`')
+
     { type: type, name: name, escaped: escaped }.to_json(*a)
   end
 end
@@ -71,7 +87,7 @@ class RBS::Types::Record
     # Explicitly not using Enumerable#to_h here to support Ruby 2.5
     fields.each do |key, type|
       if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) &&
-           !key.match?(RBS::Parser::KEYWORDS_RE)
+           !key.match?(RBS::KEYWORD_RAW)
         fields_extra[key] = { type: type, joiner: :label }
       else
         fields_extra[key.inspect] = { type: type, joiner: :rocket }
@@ -82,6 +98,47 @@ class RBS::Types::Record
   end
 end
 
+if defined?(RBS::AST::Declarations::ModuleTypeParams)
+  # This class was removed in rbs 2.0. Monkeypatch < 2.0 to give the same json
+  # output
+  class RBS::AST::Declarations::ModuleTypeParams
+    def to_json(*a)
+      params.to_json(*a)
+    end
+  end
+
+  # make this look like the new AST::TypeParam json
+  class RBS::AST::Declarations::ModuleTypeParams::TypeParam
+    def to_json(*a)
+      { name: name, variance: variance, unchecked: skip_validation }.to_json(*a)
+    end
+  end
+
+  # https://github.com/ruby/rbs/commit/3ccdcb1f3ac5dcb866280f745866a852658195e6
+  class RBS::MethodType
+    # promote the array of symbols into TypeParam looking-things
+    def to_json(*a)
+      type_param_objects =
+        type_params.map do |name|
+          {
+            name: name,
+            variance: 'invariant',
+            unchecked: 'false',
+            upper_bound: nil
+            # location - harder to get this but not needed
+          }
+        end
+
+      {
+        type_params: type_param_objects,
+        type: type,
+        block: block,
+        location: location
+      }.to_json(*a)
+    end
+  end
+end
+
 # The main parser interface.
 module Prettier
   class RBSParser

data/dist/rbs/printer.js

@@ -228,7 +228,7 @@ const printer = {
             const preferredQuote = opts.rubySingleQuote ? "'" : '"';
             // Determine if we're allowed to change the quote based on whether or not
             // there is an escape sequence in the source string.
-            const quote = node.literal.includes("\\")
+            const quote = value.match(new RegExp(`\\\\[^${originalQuote}]`))
                 ? originalQuote
                 : preferredQuote;
             return makeString(value.slice(1, -1), quote, false);
@@ -367,13 +367,13 @@ const printer = {
         // Additionally loops through each type parameter if there are any and print
         // them out joined by commas. Checks for validation and variance.
         function printNameAndTypeParams(path, node) {
-            if (node.type_params.params.length === 0) {
+            if (node.type_params.length === 0) {
                 return node.name;
             }
             const docs = path.map((paramPath) => {
                 const node = paramPath.getValue();
                 const parts = [];
-                if (node.skip_validation) {
+                if (node.unchecked) {
                     parts.push("unchecked");
                 }
                 if (node.variance === "covariant") {
@@ -382,8 +382,15 @@ const printer = {
                 else if (node.variance === "contravariant") {
                     parts.push("in");
                 }
-                return join(" ", [...parts, node.name]);
-            }, "type_params", "params");
+                if (node.upper_bound) {
+                    const path = paramPath;
+                    const upperBound = path.call(printType, "upper_bound");
+                    return join(" ", [...parts, node.name, "<", upperBound]);
+                }
+                else {
+                    return join(" ", [...parts, node.name]);
+                }
+            }, "type_params");
             return [node.name, "[", join(", ", docs), "]"];
         }
         // Returns an array of printed parameters so that the calling function can
@@ -455,7 +462,8 @@ const printer = {
             const parts = [];
             // We won't have a type_params key if we're printing a block
             if (node.type_params && node.type_params.length > 0) {
-                parts.push("[", join(", ", node.type_params), "] ");
+                const typeParamNames = node.type_params.map((tp) => tp.name);
+                parts.push("[", join(", ", typeParamNames), "] ");
             }
             const params = path.call(printMethodParams, "type");
             if (params.length > 0) {

data/dist/ruby/embed.js

@@ -57,6 +57,11 @@ function stripCommonLeadingWhitespace(content) {
     const minimum = getCommonLeadingWhitespace(content);
     return lines.map((line) => line.slice(minimum)).join("\n");
 }
+// A type assertion so that TypeScript knows we're working with an array of
+// exclusively plain string content.
+function isTStringContentArray(body) {
+    return body.every((part) => part.type === "tstring_content");
+}
 const embed = (path, print, textToDoc) => {
     const node = path.getValue();
     // Currently we only support embedded formatting on heredoc nodes
@@ -64,19 +69,19 @@ const embed = (path, print, textToDoc) => {
         return null;
     }
     // 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")) {
+    const { beging, parts, ending } = node;
+    const isSquiggly = beging.value[2] === "~";
+    if (!isTStringContentArray(parts)) {
         return null;
     }
     // Next, find the parser associated with this heredoc (if there is one). For
     // example, if you use <<~CSS, we'd hook it up to the css parser.
-    const parser = parsers[beging.body.slice(3).toLowerCase()];
+    const parser = parsers[beging.value.slice(3).toLowerCase()];
     if (!parser) {
         return null;
     }
     // Get the content as if it were a source string.
-    let content = body.map((part) => part.body).join("");
+    let content = parts.map((part) => part.value).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.

data/dist/ruby/location.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEndChar = exports.getEndLine = exports.getStartChar = exports.getStartLine = void 0;
+function getStartLine(location) {
+    return location[0];
+}
+exports.getStartLine = getStartLine;
+function getStartChar(location) {
+    return location[1];
+}
+exports.getStartChar = getStartChar;
+function getEndLine(location) {
+    return location[2];
+}
+exports.getEndLine = getEndLine;
+function getEndChar(location) {
+    return location[3];
+}
+exports.getEndChar = getEndChar;

data/dist/ruby/nodes/alias.js

@@ -27,6 +27,7 @@ const { addTrailingComment, align, group, hardline, line } = prettier_1.default;
 // the symbol literal `bar` and the right could be the symbol literal `foo`.
 const printAlias = (path, opts, print) => {
     const keyword = "alias ";
+    const node = path.getValue();
     // 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.
@@ -38,21 +39,21 @@ const printAlias = (path, opts, print) => {
             // otherwise we could accidentally skip printing them.
             if (argNode.comments) {
                 argNode.comments.forEach((comment) => {
-                    addTrailingComment(argNode.body[0], comment);
+                    addTrailingComment(argNode.value, comment);
                 });
             }
-            return argPath.call(print, "body", 0);
+            return argPath.call(print, "value");
         }
         return print(argPath);
     };
     return group([
         keyword,
-        path.call(printAliasArg, "body", 0),
+        path.call(printAliasArg, "left"),
         group(align(keyword.length, [
             // If the left child has any comments, then we need to explicitly break
             // this into two lines
-            path.getValue().body[0].comments ? hardline : line,
-            path.call(printAliasArg, "body", 1)
+            node.left.comments ? hardline : line,
+            path.call(printAliasArg, "right")
         ]))
     ]);
 };

data/dist/ruby/nodes/aref.js

@@ -19,9 +19,8 @@ const { group, indent, join, line, softline } = prettier_1.default;
 //     foo[]
 //
 const printAref = (path, opts, print) => {
-    const indexNode = path.getValue().body[1];
-    if (!indexNode) {
-        return [path.call(print, "body", 0), "[]"];
+    if (!path.getValue().index) {
+        return [path.call(print, "collection"), "[]"];
     }
     return (0, exports.printArefField)(path, opts, print);
 };
@@ -41,11 +40,10 @@ exports.printAref = printAref;
 //     foo[bar] = baz
 //
 const printArefField = (path, opts, print) => {
-    const [printedArray, printedIndex] = path.map(print, "body");
     return group([
-        printedArray,
+        path.call(print, "collection"),
         "[",
-        indent([softline, join([",", line], printedIndex)]),
+        indent([softline, join([",", line], path.call(print, "index"))]),
         softline,
         "]"
     ]);

data/dist/ruby/nodes/args.js

@@ -3,27 +3,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printBlockArg = exports.printArgsAddStar = exports.printArgsAddBlock = exports.printArgs = exports.printArgParen = void 0;
+exports.printArgStar = exports.printBlockArg = exports.printArgsAddBlock = exports.printArgs = exports.printArgParen = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const toProc_1 = __importDefault(require("../toProc"));
 const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
 const noTrailingComma = ["command", "command_call"];
+function getArgs(node) {
+    switch (node.type) {
+        case "args":
+            return node.parts;
+        case "args_add_block": {
+            const args = getArgs(node.args);
+            return node.block ? [...args, node.block] : args;
+        }
+    }
+}
 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]) {
+    if (node.type === "args_add_block" && node.block) {
         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)) {
+    const args = getArgs(node);
+    if (args.length === 1 && noTrailingComma.includes(args[0].type)) {
         return "";
     }
     return ifBreak(",", "");
 }
 const printArgParen = (path, opts, print) => {
-    const argsNode = path.getValue().body[0];
+    const argsNode = path.getValue().args;
     if (argsNode === null) {
         return "";
     }
@@ -33,7 +44,7 @@ const printArgParen = (path, opts, print) => {
     if (argsNode.type === "args_forward") {
         return group([
             "(",
-            indent([softline, path.call(print, "body", 0)]),
+            indent([softline, path.call(print, "args")]),
             softline,
             ")"
         ]);
@@ -44,7 +55,7 @@ const printArgParen = (path, opts, print) => {
         "(",
         indent([
             softline,
-            join([",", line], path.call(print, "body", 0)),
+            join([",", line], path.call(print, "args")),
             (0, utils_1.getTrailingComma)(opts) ? getArgParenTrailingComma(argsNode) : ""
         ]),
         softline,
@@ -53,7 +64,7 @@ const printArgParen = (path, opts, print) => {
 };
 exports.printArgParen = printArgParen;
 const printArgs = (path, { rubyToProc }, print) => {
-    const args = path.map(print, "body");
+    const args = path.map(print, "parts");
     // Don't bother trying to do any kind of fancy toProc transform if the
     // option is disabled.
     if (rubyToProc) {
@@ -67,7 +78,7 @@ const printArgs = (path, { rubyToProc }, print) => {
             blockNode =
                 parentNode &&
                     parentNode.type === "method_add_block" &&
-                    parentNode.body[1];
+                    parentNode.block;
             return blockNode;
         });
         const proc = blockNode && (0, toProc_1.default)(path, blockNode);
@@ -87,11 +98,10 @@ const printArgs = (path, { rubyToProc }, print) => {
 exports.printArgs = printArgs;
 const printArgsAddBlock = (path, opts, print) => {
     const node = path.getValue();
-    const blockNode = node.body[1];
-    const parts = path.call(print, "body", 0);
-    if (blockNode) {
-        let blockDoc = path.call(print, "body", 1);
-        if (!(blockNode.comments || []).some(({ leading }) => leading)) {
+    const parts = path.call(print, "args");
+    if (node.block) {
+        let blockDoc = path.call(print, "block");
+        if (!(node.block.comments || []).some(({ leading }) => leading)) {
             // If we don't have any leading comments, we can just prepend the
             // operator.
             blockDoc = ["&", blockDoc];
@@ -117,49 +127,12 @@ const printArgsAddBlock = (path, opts, print) => {
     return parts;
 };
 exports.printArgsAddBlock = printArgsAddBlock;
-const printArgsAddStar = (path, opts, print) => {
-    let docs = [];
-    path.each((argPath, argIndex) => {
-        const doc = print(argPath);
-        // If it's the first child, then it's an array of args, so we're going to
-        // concat that onto the existing docs if there are any.
-        if (argIndex === 0) {
-            if (doc.length > 0) {
-                docs = docs.concat(doc);
-            }
-            return;
-        }
-        // If it's after the splat, then it's an individual arg, so we're just going
-        // to push it onto the array.
-        if (argIndex !== 1) {
-            docs.push(doc);
-            return;
-        }
-        // If we don't have any leading comments, we can just prepend the operator.
-        const argsNode = argPath.getValue();
-        if (!(argsNode.comments || []).some(({ leading }) => leading)) {
-            docs.push(["*", doc]);
-            return;
-        }
-        // If we have an array like:
-        //
-        //     [
-        //       # comment
-        //       *values
-        //     ]
-        //
-        // then we need to make sure we don't accidentally prepend the operator
-        // before the comment(s).
-        //
-        // In prettier >= 2.3.0, the comments are printed as an array before the
-        // content. I don't love this kind of reflection, but it's the simplest way
-        // at the moment to get this right.
-        docs.push(doc[0].concat(["*", doc[1]], doc.slice(2)));
-    }, "body");
-    return docs;
-};
-exports.printArgsAddStar = printArgsAddStar;
 const printBlockArg = (path, opts, print) => {
-    return ["&", path.call(print, "body", 0)];
+    return ["&", path.call(print, "name")];
 };
 exports.printBlockArg = printBlockArg;
+const printArgStar = (path, opts, print) => {
+    const node = path.getValue();
+    return node.value ? ["*", path.call(print, "value")] : "*";
+};
+exports.printArgStar = printArgStar;