prettier 1.0.0 → 1.2.2

data/src/nodes/return.js

@@ -13,10 +13,13 @@ const { literal } = require("../utils");
 // because they have low enough operator precedence that you need to explicitly
 // keep them in there.
 const canSkipParens = (args) => {
-  const statement = args.body[0].body[0].body[0];
-  return (
-    statement.type !== "binary" || !["and", "or"].includes(statement.body[1])
-  );
+  const stmts = args.body[0].body[0];
+  if (stmts.comments) {
+    return false;
+  }
+
+  const stmt = stmts.body[0];
+  return stmt.type !== "binary" || !["and", "or"].includes(stmt.body[1]);
 };
 
 const printReturn = (path, opts, print) => {
@@ -27,25 +30,27 @@ const printReturn = (path, opts, print) => {
     return "return";
   }
 
-  // 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
-  // want them.
-  if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
-    args = args.body[0].body[0];
-    steps = steps.concat("body", 0, "body", 0);
-  }
+  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
+    // want them.
+    if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
+      args = args.body[0].body[0];
+      steps = steps.concat("body", 0, "body", 0);
+    }
 
-  // If we're returning an array literal that isn't a special array, single
-  // element array, or an empty array, then we want to grab the arguments so
-  // that we can print them out as if they were normal return arguments.
-  if (
-    args.body[0] &&
-    args.body[0].type === "array" &&
-    args.body[0].body[0] &&
-    args.body[0].body[0].body.length > 1 &&
-    ["args", "args_add_star"].includes(args.body[0].body[0].type)
-  ) {
-    steps = steps.concat("body", 0, "body", 0);
+    // If we're returning an array literal that isn't a special array, single
+    // element array, or an empty array, then we want to grab the arguments so
+    // that we can print them out as if they were normal return arguments.
+    if (
+      args.body[0] &&
+      args.body[0].type === "array" &&
+      args.body[0].body[0] &&
+      args.body[0].body[0].body.length > 1 &&
+      ["args", "args_add_star"].includes(args.body[0].body[0].type)
+    ) {
+      steps = steps.concat("body", 0, "body", 0);
+    }
   }
 
   // Now that we've established which actual node is the arguments to return,
@@ -56,6 +61,12 @@ const printReturn = (path, opts, print) => {
   // be a singular doc as opposed to an array.
   const value = Array.isArray(parts) ? join(concat([",", line]), parts) : parts;
 
+  // We only get here if we have comments somewhere that would prevent us from
+  // skipping the parentheses.
+  if (args.body.length === 1 && args.body[0].type === "paren") {
+    return concat(["return", value]);
+  }
+
   return group(
     concat([
       "return",

data/src/nodes/statements.js

@@ -98,8 +98,8 @@ module.exports = {
       stmts[0].comments
     ) {
       const comments = path.map(
-        (commentPath, index) => {
-          stmts[0].comments[index].printed = true;
+        (commentPath) => {
+          commentPath.getValue().printed = true;
           return opts.printer.printComment(commentPath);
         },
         "body",

data/src/parser.rb

@@ -63,14 +63,14 @@ class Prettier::Parser < Ripper
   # would happen to be the innermost keyword). Then the outer one would only be
   # able to grab the first one. In this way all of the scanner events act as
   # their own stack.
-  def find_scanner_event(type, body = :any)
+  def find_scanner_event(type, body = :any, consume: true)
     index =
       scanner_events.rindex do |scanner_event|
         scanner_event[:type] == type &&
           (body == :any || (scanner_event[:body] == body))
       end
 
-    scanner_events.delete_at(index)
+    consume ? scanner_events.delete_at(index) : (index && scanner_events[index])
   end
 
   # Scanner events occur when the lexer hits a new token, like a keyword or an
@@ -675,8 +675,15 @@ class Prettier::Parser < Ripper
   # It accepts as arguments the switch of the case and the consequent
   # clause.
   def on_case(switch, consequent)
-    find_scanner_event(:@kw, 'case').merge!(
-      type: :case,
+    beging =
+      if event = find_scanner_event(:@kw, 'case', consume: false)
+        scanner_events.delete(event).merge!(type: :case)
+      else
+        keyword = find_scanner_event(:@kw, 'in', consume: false)
+        switch.merge(type: :rassign, keyword: keyword)
+      end
+
+    beging.merge!(
       body: [switch, consequent],
       end: consequent[:end],
       char_end: consequent[:char_end]
@@ -746,6 +753,11 @@ class Prettier::Parser < Ripper
   # of the method, the operator being used to send the method, the name of
   # the method, and the arguments being passed to the method.
   def on_command_call(receiver, oper, ident, args)
+    # Make sure we take the operator out of the scanner events so that it
+    # doesn't get confused for a unary operator later.
+    scanner_events.delete(oper)
+
+    # Grab the ending from either the arguments or the method being sent
     ending = args || ident
 
     {
@@ -814,18 +826,43 @@ class Prettier::Parser < Ripper
   #          │   └> params
   #          └> ident
   #
+  # You can also have single-line methods since Ruby 3.0+, which have slightly
+  # different syntax but still flow through this method. Those look like:
+  #
+  #     def foo = bar
+  #          |     |
+  #          |     └> stmt
+  #          └> ident
+  #
   def on_def(ident, params, bodystmt)
     # Make sure to delete this scanner event in case you're defining something
     # like def class which would lead to this being a kw and causing all kinds
     # of trouble
     scanner_events.delete(ident)
 
+    # Find the beginning of the method definition, which works for single-line
+    # and normal method definitions.
+    beging = find_scanner_event(:@kw, 'def')
+
+    # If we don't have a bodystmt node, then we have a single-line method
+    if bodystmt[:type] != :bodystmt
+      return(
+        {
+          type: :defsl,
+          body: [ident, params, bodystmt],
+          start: beging[:start],
+          char_start: beging[:char_start],
+          end: bodystmt[:end],
+          char_end: bodystmt[:char_end]
+        }
+      )
+    end
+
     if params[:type] == :params && !params[:body].any?
       location = ident[:char_end]
       params.merge!(char_start: location, char_end: location)
     end
 
-    beging = find_scanner_event(:@kw, 'def')
     ending = find_scanner_event(:@kw, 'end')
 
     bodystmt.bind(
@@ -981,7 +1018,7 @@ class Prettier::Parser < Ripper
   #
   # which would be the same symbol as above.
   def on_dyna_symbol(string)
-    if scanner_events.any? { |event| event[:type] == :@symbeg }
+    if find_scanner_event(:@symbeg, consume: false)
       # A normal dynamic symbol
       beging = find_scanner_event(:@symbeg)
       ending = find_scanner_event(:@tstring_end)
@@ -1157,6 +1194,24 @@ class Prettier::Parser < Ripper
     }
   end
 
+  # fndptn is a parser event that represents matching against a pattern where
+  # you find a pattern in an array using the Ruby 3.0+ pattern matching syntax.
+  def on_fndptn(const, presplat, args, postsplat)
+    beging = const || find_scanner_event(:@lbracket)
+    ending = find_scanner_event(:@rbracket)
+
+    pieces = [const, presplat, *args, postsplat].compact
+
+    {
+      type: :fndptn,
+      body: [const, presplat, args, postsplat],
+      start: beging[:start],
+      char_start: beging[:char_start],
+      end: ending[:end],
+      char_end: ending[:char_end]
+    }
+  end
+
   # for is a parser event that represents using the somewhat esoteric for
   # loop. It accepts as arguments an ident which is the iterating variable,
   # an enumerable for that which is being enumerated, and a stmts event that
@@ -1302,8 +1357,12 @@ class Prettier::Parser < Ripper
   end
 
   # in is a parser event that represents using the in keyword within the
-  # Ruby 2.7+ pattern matching syntax.
+  # Ruby 2.7+ pattern matching syntax. Alternatively in Ruby 3+ it is also used
+  # to handle rightward assignment for pattern matching.
   def on_in(pattern, stmts, consequent)
+    # Here we have a rightward assignment
+    return pattern unless stmts
+
     beging = find_scanner_event(:@kw, 'in')
     ending = consequent || find_scanner_event(:@kw, 'end')
 
@@ -1341,8 +1400,8 @@ class Prettier::Parser < Ripper
   def on_lambda(params, stmts)
     beging = find_scanner_event(:@tlambda)
 
-    if scanner_events.any? { |event| event[:type] == :@tlambeg }
-      opening = find_scanner_event(:@tlambeg)
+    if event = find_scanner_event(:@tlambeg, consume: false)
+      opening = scanner_events.delete(event)
       closing = find_scanner_event(:@rbrace)
     else
       opening = find_scanner_event(:@kw, 'do')
@@ -1719,7 +1778,8 @@ class Prettier::Parser < Ripper
   # expression literal, like /foo/. It can be followed by any number of
   # regexp_add events, which we'll append onto an array body.
   def on_regexp_new
-    find_scanner_event(:@regexp_beg).merge!(type: :regexp, body: [])
+    beging = find_scanner_event(:@regexp_beg)
+    beging.merge!(type: :regexp, body: [], beging: beging[:body])
   end
 
   # regexp_add is a parser event that represents a piece of a regular
@@ -2305,7 +2365,7 @@ class Prettier::Parser < Ripper
     else
       # You can hit this pattern if you're assigning to a splat using pattern
       # matching syntax in Ruby 2.7+
-      { type: :var_field, body: [] }
+      { type: :var_field, body: nil }
     end
   end
 

data/src/printer.js

@@ -20,6 +20,18 @@ function printNode(path, opts, print) {
   throw new Error(`Unsupported node encountered: ${type}\n${ast}`);
 }
 
+// This is an escape-hatch to ignore nodes in the tree. If you have a comment
+// that includes this pattern, then the entire node will be ignored and just the
+// original source will be printed out.
+function hasPrettierIgnore(path) {
+  const node = path.getValue();
+
+  return (
+    node.comments &&
+    node.comments.some((comment) => comment.value.includes("prettier-ignore"))
+  );
+}
+
 const noComments = [
   "args",
   "args_add_block",
@@ -55,6 +67,38 @@ function getCommentChildNodes(node) {
 
       return [node.body[0]].concat(values).concat(node.body[2]);
     }
+    case "params": {
+      const [reqs, optls, rest, post, kwargs, kwargRest, block] = node.body;
+      let parts = reqs || [];
+
+      (optls || []).forEach((optl) => {
+        parts = parts.concat(optl);
+      });
+
+      if (rest) {
+        parts.push(rest);
+      }
+
+      parts = parts.concat(post || []);
+
+      (kwargs || []).forEach((kwarg) => {
+        if (kwarg[1]) {
+          parts = parts.concat(kwarg);
+        } else {
+          parts.push(kwarg[0]);
+        }
+      });
+
+      if (kwargRest && kwargRest !== "nil") {
+        parts.push(kwargRest);
+      }
+
+      if (block) {
+        parts.push(block);
+      }
+
+      return parts;
+    }
     default:
       return node.body;
   }
@@ -83,6 +127,7 @@ function isBlockComment(comment) {
 module.exports = {
   embed,
   print: printNode,
+  hasPrettierIgnore,
   canAttachComment,
   getCommentChildNodes,
   printComment,

data/src/utils.js

@@ -1,6 +1,7 @@
 const { concat } = require("./prettier");
 const isEmptyStmts = require("./utils/isEmptyStmts");
 const literalLineNoBreak = require("./utils/literalLineNoBreak");
+const printEmptyCollection = require("./utils/printEmptyCollection");
 
 // If the node is a type of assignment or if the node is a paren and nested
 // inside that paren is a node that is a type of assignment.
@@ -89,5 +90,6 @@ module.exports = {
   makeCall,
   noIndent,
   prefix,
+  printEmptyCollection,
   skipAssignIndent
 };

data/src/utils/printEmptyCollection.js

@@ -0,0 +1,42 @@
+const { concat, group, hardline, indent, join, line } = require("../prettier");
+
+// Empty collections are array or hash literals that do not contain any
+// contents. They can, however, have comments inside the body. You can solve
+// this by having a child node inside the array that gets the comments attached
+// to it, but that requires modifying the parser. Instead, we can just manually
+// print out the non-leading comments here.
+function printEmptyCollection(path, opts, startToken, endToken) {
+  const node = path.getValue();
+
+  // If there are no comments or only leading comments, then we can just print
+  // out the start and end token and be done, as there are no comments inside
+  // the body of this node.
+  if (!node.comments || !node.comments.some((comment) => !comment.leading)) {
+    return `${startToken}${endToken}`;
+  }
+
+  const comments = [];
+
+  // For each comment, go through its path and print it out manually.
+  const printComment = (commentPath) => {
+    const comment = commentPath.getValue();
+
+    if (!comment.leading) {
+      comment.printed = true;
+      comments.push(opts.printer.printComment(commentPath));
+    }
+  };
+
+  path.each(printComment, "comments");
+
+  return group(
+    concat([
+      startToken,
+      indent(concat([hardline, join(hardline, comments)])),
+      line,
+      endToken
+    ])
+  );
+}
+
+module.exports = printEmptyCollection;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-11 00:00:00.000000000 Z
+date: 2021-01-01 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -73,6 +73,7 @@ files:
 - src/utils/inlineEnsureParens.js
 - src/utils/isEmptyStmts.js
 - src/utils/literalLineNoBreak.js
+- src/utils/printEmptyCollection.js
 homepage: https://github.com/prettier/plugin-ruby#readme
 licenses:
 - MIT
@@ -92,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language