prettier 1.4.0 → 1.5.4

data/src/ruby/nodes/methods.js

@@ -1,8 +1,9 @@
 const { concat, group, hardline, indent, line } = require("../../prettier");
+const { isEmptyBodyStmt } = require("../../utils");
 
 function printMethod(offset) {
   return function printMethodWithOffset(path, opts, print) {
-    const [_name, params, body] = path.getValue().body.slice(offset);
+    const [_name, params, bodystmt] = path.getValue().body.slice(offset);
     const declaration = ["def "];
 
     // In this case, we're printing a method that's defined as a singleton, so
@@ -24,16 +25,8 @@ function printMethod(offset) {
       parens ? ")" : ""
     );
 
-    // If the body is empty, we can replace with a ;
-    const stmts = body.body[0].body;
-
-    if (
-      !body.body.slice(1).some((node) => node) &&
-      stmts.length === 1 &&
-      stmts[0].type === "void_stmt" &&
-      !stmts[0].comments
-    ) {
-      return group(concat(declaration.concat(["; end"])));
+    if (isEmptyBodyStmt(bodystmt)) {
+      return group(concat(declaration.concat("; end")));
     }
 
     return group(

data/src/ruby/nodes/statements.js

@@ -12,15 +12,13 @@ const {
   trim
 } = require("../../prettier");
 
+const { isEmptyStmts } = require("../../utils");
+
 function printBodyStmt(path, opts, print) {
   const [stmts, rescue, elseClause, ensure] = path.getValue().body;
   const parts = [];
 
-  if (
-    stmts.body.length > 1 ||
-    stmts.body[0].type != "void_stmt" ||
-    stmts.body[0].comments
-  ) {
+  if (!isEmptyStmts(stmts)) {
     parts.push(path.call(print, "body", 0));
   }
 

data/src/ruby/parser.js

@@ -4,8 +4,8 @@ const parseSync = require("../parser/parseSync");
 // to prettier a JavaScript object that is the equivalent AST that represents
 // the code stored in that string. We accomplish this by spawning a new Ruby
 // process of parser.rb and reading JSON off STDOUT.
-function parse(text, _parsers, _opts) {
-  return parseSync("ruby", text);
+function parse(text, _parsers, opts) {
+  return parseSync("ruby", text, opts);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/ruby/parser.rb

@@ -17,10 +17,44 @@ require 'delegate'
 require 'json'
 require 'ripper'
 
-module Prettier; end
+module Prettier
+end
 
 class Prettier::Parser < Ripper
-  attr_reader :source, :lines, :scanner_events, :line_counts
+  # Represents a line in the source. If this class is being used, it means that
+  # every character in the string is 1 byte in length, so we can just return the
+  # start of the line + the index.
+  class SingleByteString
+    def initialize(start)
+      @start = start
+    end
+
+    def [](byteindex)
+      @start + byteindex
+    end
+  end
+
+  # Represents a line in the source. If this class is being used, it means that
+  # there are characters in the string that are multi-byte, so we will build up
+  # an array of indices, such that array[byteindex] will be equal to the index
+  # of the character within the string.
+  class MultiByteString
+    def initialize(start, line)
+      @indices = []
+
+      line
+        .each_char
+        .with_index(start) do |char, index|
+          char.bytesize.times { @indices << index }
+        end
+    end
+
+    def [](byteindex)
+      @indices[byteindex]
+    end
+  end
+
+  attr_reader :source, :lines, :scanner_events
 
   # This is an attr_accessor so Stmts objects can grab comments out of this
   # array and attach them to themselves.
@@ -39,9 +73,23 @@ class Prettier::Parser < Ripper
     @heredocs = []
 
     @scanner_events = []
-    @line_counts = [0]
+    @line_counts = []
 
-    @source.lines.each { |line| @line_counts << @line_counts.last + line.size }
+    # Here we're going to build up a list of SingleByteString or MultiByteString
+    # objects. They're each going to represent a string in the source. They are
+    # used by the `char_pos` method to determine where we are in the source
+    # string.
+    last_index = 0
+
+    @source.lines.each do |line|
+      if line.size == line.bytesize
+        @line_counts << SingleByteString.new(last_index)
+      else
+        @line_counts << MultiByteString.new(last_index, line)
+      end
+
+      last_index += line.size
+    end
   end
 
   def self.parse(source)
@@ -59,7 +107,7 @@ class Prettier::Parser < Ripper
   # this line, then we add the number of columns into this line that we've gone
   # through.
   def char_pos
-    line_counts[lineno - 1] + column
+    @line_counts[lineno - 1][column]
   end
 
   # As we build up a list of scanner events, we'll periodically need to go
@@ -517,6 +565,12 @@ class Prettier::Parser < Ripper
   # binary is a parser event that represents a binary operation between two
   # values.
   def on_binary(left, oper, right)
+    # On most Ruby implementations, oper is a Symbol that represents that
+    # operation being performed. For instance in the example `1 < 2`, the `oper`
+    # object would be `:<`. However, on JRuby, it's an `@op` node, so here we're
+    # going to explicitly convert it into the same normalized form.
+    oper = scanner_events.delete(oper)[:body] unless oper.is_a?(Symbol)
+
     {
       type: :binary,
       body: [left, oper, right],
@@ -1675,6 +1729,28 @@ class Prettier::Parser < Ripper
     )
   end
 
+  # A special parser error so that we can get nice syntax displays on the error
+  # message when prettier prints out the results.
+  class ParserError < StandardError
+    attr_reader :lineno, :column
+
+    def initialize(error, lineno, column)
+      super(error)
+      @lineno = lineno
+      @column = column
+    end
+  end
+
+  # If we encounter a parse error, just immediately bail out so that our runner
+  # can catch it.
+  def on_parse_error(error, *)
+    raise ParserError.new(error, lineno, column)
+  end
+  alias on_alias_error on_parse_error
+  alias on_assign_error on_parse_error
+  alias on_class_name_error on_parse_error
+  alias on_param_error on_parse_error
+
   # The program node is the very top of the AST. Here we'll attach all of
   # the comments that we've gathered up over the course of parsing the
   # source string. We'll also attach on the __END__ content if there was

data/src/ruby/printer.js

@@ -38,7 +38,8 @@ const noComments = [
   "args_add_star",
   "mlhs",
   "mlhs_add_post",
-  "mlhs_add_star"
+  "mlhs_add_star",
+  "mlhs_paren"
 ];
 
 // Certain nodes are used more for organizational purposed than for actually
@@ -97,8 +98,12 @@ function getCommentChildNodes(node) {
 
       return parts;
     }
-    default:
-      return node.body;
+    default: {
+      if (Array.isArray(node.body)) {
+        return node.body.filter((child) => child && typeof child === "object");
+      }
+      return [];
+    }
   }
 }
 

data/src/utils.js

@@ -1,10 +1,11 @@
 module.exports = {
   containsAssignment: require("./utils/containsAssignment"),
   getTrailingComma: require("./utils/getTrailingComma"),
+  isEmptyBodyStmt: require("./utils/isEmptyBodyStmt"),
   isEmptyStmts: require("./utils/isEmptyStmts"),
   hasAncestor: require("./utils/hasAncestor"),
   literal: require("./utils/literal"),
-  literalLineNoBreak: require("./utils/literalLineNoBreak"),
+  literallineWithoutBreakParent: require("./utils/literallineWithoutBreakParent"),
   makeCall: require("./utils/makeCall"),
   noIndent: require("./utils/noIndent"),
   printEmptyCollection: require("./utils/printEmptyCollection"),

data/src/utils/inlineEnsureParens.js

@@ -1,4 +1,11 @@
-const needsParens = ["args", "assign", "assoc_new", "massign", "opassign"];
+const needsParens = [
+  "args",
+  "assign",
+  "assoc_new",
+  "call",
+  "massign",
+  "opassign"
+];
 
 // If you have a modifier statement (for instance an inline if statement or an
 // inline while loop) there are times when you need to wrap the entire statement

data/src/utils/isEmptyBodyStmt.js

@@ -0,0 +1,7 @@
+const isEmptyStmts = require("./isEmptyStmts");
+
+function isEmptyBodyStmt(node) {
+  return isEmptyStmts(node.body[0]) && !node.body.slice(1).some(Boolean);
+}
+
+module.exports = isEmptyBodyStmt;

data/src/utils/isEmptyStmts.js

@@ -1,7 +1,11 @@
-const isEmptyStmts = (node) =>
-  node &&
-  node.type === "stmts" &&
-  node.body.length === 1 &&
-  node.body[0].type === "void_stmt";
+function isEmptyStmts(node) {
+  return (
+    node &&
+    node.type === "stmts" &&
+    node.body.length === 1 &&
+    node.body[0].type === "void_stmt" &&
+    !node.body[0].comments
+  );
+}
 
 module.exports = isEmptyStmts;

data/src/utils/literallineWithoutBreakParent.js

@@ -0,0 +1,7 @@
+const literallineWithoutBreakParent = {
+  type: "line",
+  hard: true,
+  literal: true
+};
+
+module.exports = literallineWithoutBreakParent;

data/src/utils/printEmptyCollection.js

@@ -1,5 +1,11 @@
 const { concat, group, hardline, indent, join, line } = require("../prettier");
 
+function containedWithin(node) {
+  return function containedWithinNode(comment) {
+    return comment.sc >= node.sc && comment.ec <= node.ec;
+  };
+}
+
 // 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
@@ -7,11 +13,12 @@ const { concat, group, hardline, indent, join, line } = require("../prettier");
 // print out the non-leading comments here.
 function printEmptyCollection(path, opts, startToken, endToken) {
   const node = path.getValue();
+  const containedWithinNode = containedWithin(node);
 
   // 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)) {
+  if (!node.comments || !node.comments.some(containedWithinNode)) {
     return `${startToken}${endToken}`;
   }
 
@@ -21,7 +28,7 @@ function printEmptyCollection(path, opts, startToken, endToken) {
   const printComment = (commentPath) => {
     const comment = commentPath.getValue();
 
-    if (!comment.leading) {
+    if (containedWithinNode(comment)) {
       comment.printed = true;
       comments.push(opts.printer.printComment(commentPath));
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.4
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-15 00:00:00.000000000 Z
+date: 2021-03-17 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -97,9 +97,10 @@ files:
 - src/utils/getTrailingComma.js
 - src/utils/hasAncestor.js
 - src/utils/inlineEnsureParens.js
+- src/utils/isEmptyBodyStmt.js
 - src/utils/isEmptyStmts.js
 - src/utils/literal.js
-- src/utils/literalLineNoBreak.js
+- src/utils/literallineWithoutBreakParent.js
 - src/utils/makeCall.js
 - src/utils/noIndent.js
 - src/utils/printEmptyCollection.js
@@ -123,7 +124,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

data/src/utils/literalLineNoBreak.js

@@ -1,7 +0,0 @@
-const literalLineNoBreak = {
-  type: "line",
-  hard: true,
-  literal: true
-};
-
-module.exports = literalLineNoBreak;