prettier 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c97988d5dd7fe35aa5fd73777f31f8217809ea0eee189cab7ac70c266569857b
-  data.tar.gz: 478c15e6cbd8d8efb16fc37e028afb8c88f3671aa77f36d3df0cd115b239c83a
+  metadata.gz: 3abef3acea4e49130ba81afdb9bc00e73277c69e0254a1087b2c5e47feb5b104
+  data.tar.gz: e851f061fc14352b7797ac0e2aca10c43f052b8bd19aa817473cfb6b75bde44c
 SHA512:
-  metadata.gz: 38ae06510c4872ba7f4ede36dc6b5f4aae3c7183c9c48b4e515733074e9ce27d2ddb4b189c25600d1daf123b8f5eccbb8b12c953e5192a62e08a63cb9716298e
-  data.tar.gz: 9456c53fe9ad823defb3d69fd4dd4504ee1e9d4af5d522fd8352141d61a5d975aa6043b62d78dd077f000258e400ee98fce8131ada5dac066021bb27e9f40de5
+  metadata.gz: 6fd8aba1071ff34709e7f3ad3ddd256cfbdc890ffb02fdef3d3567331a53d9b1974d02fd943ce03cab565822d750288bbe5582bc3c4a2d26bf0f170d2c3d15c6
+  data.tar.gz: 8e66f396c113f162fb6c8c747a60d45dd38a554c13cab3ac1ae12456ff15fc49d2945ce69c1db53d89f1f82a69d0b30017ebfdcd99fbb2cb2fbbc29c4dbf398b

data/CHANGELOG.md

@@ -6,6 +6,16 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.2.1] - 2020-12-27
+
+### Changed
+
+- [@kddeisz] - Handle single-line method definitions with parameters.
+- [@kddeisz] - Handle hash and array patterns nested within find patterns.
+- [@kddeisz] - Handle rightward assignment.
+- [@kddeisz] - Handle find patterns with named boundaries.
+- [@kddeisz] - Handle rightward assignment in conditionals.
+
 ## [1.2.0] - 2020-12-26
 
 ### Added

data/package.json

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

data/src/nodes/assign.js

@@ -32,11 +32,7 @@ function printOpAssign(path, opts, print) {
 }
 
 function printVarField(path, opts, print) {
-  if (path.getValue().body) {
-    return path.call(print, "body", 0);
-  }
-
-  return "*";
+  return path.getValue().body ? path.call(print, "body", 0) : "";
 }
 
 module.exports = {

data/src/nodes/case.js

@@ -8,54 +8,58 @@ const {
   line
 } = require("../prettier");
 
-module.exports = {
-  case: (path, opts, print) => {
-    const statement = ["case"];
-
-    // You don't need to explicitly have something to test against in a case
-    // statement (without it it effectively becomes an if/elsif chain).
-    if (path.getValue().body[0]) {
-      statement.push(" ", path.call(print, "body", 0));
-    }
-
-    return concat(
-      statement.concat([hardline, path.call(print, "body", 1), hardline, "end"])
-    );
-  },
-  when: (path, opts, print) => {
-    const [_preds, _stmts, addition] = path.getValue().body;
-
-    // The `fill` builder command expects an array of docs alternating with
-    // line breaks. This is so it can loop through and determine where to break.
-    const preds = fill(
-      path.call(print, "body", 0).reduce((accum, pred, index) => {
-        if (index === 0) {
-          return [pred];
-        }
-
-        // Pull off the last element and make it concat with a comma so that
-        // we can maintain alternating lines and docs.
-        return accum
-          .slice(0, -1)
-          .concat([concat([accum[accum.length - 1], ","]), line, pred]);
-      }, null)
-    );
-
-    const stmts = path.call(print, "body", 1);
-    const parts = [concat(["when ", align("when ".length, preds)])];
-
-    // It's possible in a when to just have empty void statements, in which case
-    // we would skip adding the body.
-    if (!stmts.parts.every((part) => !part)) {
-      parts.push(indent(concat([hardline, stmts])));
-    }
-
-    // This is the next clause on the case statement, either another `when` or
-    // an `else` clause.
-    if (addition) {
-      parts.push(hardline, path.call(print, "body", 2));
-    }
-
-    return group(concat(parts));
+function printCase(path, opts, print) {
+  const statement = ["case"];
+
+  // You don't need to explicitly have something to test against in a case
+  // statement (without it it effectively becomes an if/elsif chain).
+  if (path.getValue().body[0]) {
+    statement.push(" ", path.call(print, "body", 0));
+  }
+
+  return concat(
+    statement.concat([hardline, path.call(print, "body", 1), hardline, "end"])
+  );
+}
+
+function printWhen(path, opts, print) {
+  const [_preds, _stmts, addition] = path.getValue().body;
+
+  // The `fill` builder command expects an array of docs alternating with
+  // line breaks. This is so it can loop through and determine where to break.
+  const preds = fill(
+    path.call(print, "body", 0).reduce((accum, pred, index) => {
+      if (index === 0) {
+        return [pred];
+      }
+
+      // Pull off the last element and make it concat with a comma so that
+      // we can maintain alternating lines and docs.
+      return accum
+        .slice(0, -1)
+        .concat([concat([accum[accum.length - 1], ","]), line, pred]);
+    }, null)
+  );
+
+  const stmts = path.call(print, "body", 1);
+  const parts = [concat(["when ", align("when ".length, preds)])];
+
+  // It's possible in a when to just have empty void statements, in which case
+  // we would skip adding the body.
+  if (!stmts.parts.every((part) => !part)) {
+    parts.push(indent(concat([hardline, stmts])));
+  }
+
+  // This is the next clause on the case statement, either another `when` or
+  // an `else` clause.
+  if (addition) {
+    parts.push(hardline, path.call(print, "body", 2));
   }
+
+  return group(concat(parts));
+}
+
+module.exports = {
+  case: printCase,
+  when: printWhen
 };

data/src/nodes/methods.js

@@ -16,8 +16,7 @@ function printMethod(offset) {
     }
 
     // In case there are no parens but there are arguments
-    const parens =
-      params.type === "params" && params.body.some((paramType) => paramType);
+    const parens = params.type === "params" && params.body.some((type) => type);
 
     declaration.push(
       path.call(print, "body", offset),
@@ -49,10 +48,27 @@ function printMethod(offset) {
 }
 
 function printSingleLineMethod(path, opts, print) {
-  const [nameDoc, stmtDoc] = path.map(print, "body");
+  let paramsNode = path.getValue().body[1];
+  let paramsDoc = "";
+
+  if (paramsNode) {
+    if (paramsNode.body[0].type === "params") {
+      paramsNode = paramsNode.body[0];
+    }
+
+    if (paramsNode.type === "params" && paramsNode.body.some((type) => type)) {
+      paramsDoc = path.call(print, "body", 1);
+    }
+  }
 
   return group(
-    concat(["def ", nameDoc, " =", indent(group(concat([line, stmtDoc])))])
+    concat([
+      "def ",
+      path.call(print, "body", 0),
+      paramsDoc,
+      " =",
+      indent(group(concat([line, path.call(print, "body", 2)])))
+    ])
   );
 }
 

data/src/nodes/patterns.js

@@ -1,5 +1,7 @@
 const { concat, group, hardline, indent, join, line } = require("../prettier");
 
+const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
+
 function printPatternArg(path, opts, print) {
   // Pinning is a really special syntax in pattern matching that's not really
   // all that well supported in ripper. Here we're just going to the original
@@ -34,10 +36,7 @@ function printAryPtn(path, opts, print) {
 
   args = group(join(concat([",", line]), args));
 
-  if (
-    constant ||
-    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
-  ) {
+  if (constant || patterns.includes(path.getParentNode().type)) {
     args = concat(["[", args, "]"]);
   }
 
@@ -51,9 +50,9 @@ function printAryPtn(path, opts, print) {
 function printFndPtn(path, opts, print) {
   const [constant] = path.getValue().body;
 
-  let args = [path.call(print, "body", 1)]
+  let args = [concat(["*", path.call(print, "body", 1)])]
     .concat(path.map(print, "body", 2))
-    .concat(path.call(print, "body", 3));
+    .concat(concat(["*", path.call(print, "body", 3)]));
 
   args = concat(["[", group(join(concat([",", line]), args)), "]"]);
 
@@ -96,10 +95,8 @@ function printHshPtn(path, opts, print) {
 
   if (constant) {
     args = concat(["[", args, "]"]);
-  } else if (
-    ["aryptn", "binary", "hshptn"].includes(path.getParentNode().type)
-  ) {
-    args = concat(["{", args, "}"]);
+  } else if (patterns.includes(path.getParentNode().type)) {
+    args = concat(["{ ", args, " }"]);
   }
 
   if (constant) {
@@ -127,9 +124,23 @@ function printIn(path, opts, print) {
   return group(concat(parts));
 }
 
+function printRAssign(path, opts, print) {
+  const { keyword } = path.getValue();
+  const [leftDoc, rightDoc] = path.map(print, "body");
+
+  return group(
+    concat([
+      leftDoc,
+      keyword ? " in" : " =>",
+      group(indent(concat([line, rightDoc])))
+    ])
+  );
+}
+
 module.exports = {
   aryptn: printAryPtn,
   fndptn: printFndPtn,
   hshptn: printHshPtn,
-  in: printIn
+  in: printIn,
+  rassign: printRAssign
 };

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]
@@ -832,12 +839,12 @@ class Prettier::Parser < Ripper
     # and normal method definitions.
     beging = find_scanner_event(:@kw, 'def')
 
-    # If there is not a params node, then we have a single-line method
-    unless params
+    # If we don't have a bodystmt node, then we have a single-line method
+    if bodystmt[:type] != :bodystmt
       return(
         {
           type: :defsl,
-          body: [ident, bodystmt],
+          body: [ident, params, bodystmt],
           start: beging[:start],
           char_start: beging[:char_start],
           end: bodystmt[:end],
@@ -1006,7 +1013,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)
@@ -1345,8 +1352,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')
 
@@ -1384,8 +1395,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')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-26 00:00:00.000000000 Z
+date: 2020-12-27 00:00:00.000000000 Z
 dependencies: []
 description:
 email: