prettier 1.0.0.pre.rc2 → 1.2.1

data/src/nodes/regexp.js

@@ -1,21 +1,25 @@
 const { concat } = require("../prettier");
+const { hasAncestor } = require("../utils");
 
-function isStringContent(node) {
-  return node.type === "@tstring_content";
+function hasContent(node, pattern) {
+  return node.body.some(
+    (child) => child.type === "@tstring_content" && pattern.test(child.body)
+  );
 }
 
-function shouldUseBraces(node) {
-  const first = node.body[0];
-
-  // If the first part of this regex is plain string content and we have a
-  // space or an =, then we want to use braces because otherwise we could end up
-  // with an ambiguous operator, e.g. foo / bar/ or foo /=bar/
-  if (first && isStringContent(first) && [" ", "="].includes(first.body[0])) {
-    return true;
-  }
+// If the first part of this regex is plain string content, we have a space
+// or an =, and we're contained within a command or command_call node, then we
+// want to use braces because otherwise we could end up with an ambiguous
+// operator, e.g. foo / bar/ or foo /=bar/
+function forwardSlashIsAmbiguous(path) {
+  const node = path.getValue();
+  const firstChildNode = node.body[0];
 
-  return node.body.some(
-    (child) => isStringContent(child) && child.body.includes("/")
+  return (
+    firstChildNode &&
+    firstChildNode.type === "@tstring_content" &&
+    [" ", "="].includes(firstChildNode.body[0]) &&
+    hasAncestor(path, ["command", "command_call"])
   );
 }
 
@@ -28,13 +32,23 @@ function shouldUseBraces(node) {
 // itself. In that case we switch over to using %r with braces.
 function printRegexpLiteral(path, opts, print) {
   const node = path.getValue();
-  const useBraces = shouldUseBraces(node);
+  const docs = path.map(print, "body");
+
+  // We should use braces if using a forward slash would be ambiguous in the
+  // current context or if there's a forward slash in the content of the regexp.
+  const useBraces = forwardSlashIsAmbiguous(path) || hasContent(node, /\//);
 
-  const parts = [useBraces ? "%r{" : "/"]
-    .concat(path.map(print, "body"))
-    .concat([useBraces ? "}" : "/", node.ending.slice(1)]);
+  // If we should be using braces but we have braces in the body of the regexp,
+  // then we're just going to resort to using whatever the original content was.
+  if (useBraces && hasContent(node, /[{}]/)) {
+    return concat([node.beging].concat(docs).concat(node.ending));
+  }
 
-  return concat(parts);
+  return concat(
+    [useBraces ? "%r{" : "/"]
+      .concat(docs)
+      .concat(useBraces ? "}" : "/", node.ending.slice(1))
+  );
 }
 
 module.exports = {

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/nodes/strings.js

@@ -32,7 +32,7 @@ function isSingleQuotable(node) {
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 
 function normalizeQuotes(content, enclosingQuote, originalQuote) {
-  const replaceOther = ["'", '"'].includes(originalQuote);
+  const replaceOther = originalQuote === '"';
   const otherQuote = enclosingQuote === '"' ? "'" : '"';
 
   // Escape and unescape single and double quotes as needed to be able to

data/src/parser.js

@@ -3,18 +3,33 @@ const path = require("path");
 
 // In order to properly parse ruby code, we need to tell the ruby process to
 // parse using UTF-8. Unfortunately, the way that you accomplish this looks
-// differently depending on your platform. This object below represents all of
-// the possible values of process.platform per:
-//   https://nodejs.org/api/process.html#process_process_platform
-const LANG = {
-  aix: "C.UTF-8",
-  darwin: "en_US.UTF-8",
-  freebsd: "C.UTF-8",
-  linux: "C.UTF-8",
-  openbsd: "C.UTF-8",
-  sunos: "C.UTF-8",
-  win32: ".UTF-8"
-}[process.platform];
+// differently depending on your platform.
+const LANG = (() => {
+  const { env, platform } = process;
+  const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
+
+  // If an env var is set for the locale that already includes UTF-8 in the
+  // name, then assume we can go with that.
+  if (envValue && envValue.includes("UTF-8")) {
+    return envValue;
+  }
+
+  // Otherwise, we're going to guess which encoding to use based on the system.
+  // This is probably not the best approach in the world, as you could be on
+  // linux and not have C.UTF-8, but in that case you're probably passing an env
+  // var for it. This object below represents all of the possible values of
+  // process.platform per:
+  // https://nodejs.org/api/process.html#process_process_platform
+  return {
+    aix: "C.UTF-8",
+    darwin: "en_US.UTF-8",
+    freebsd: "C.UTF-8",
+    linux: "C.UTF-8",
+    openbsd: "C.UTF-8",
+    sunos: "C.UTF-8",
+    win32: ".UTF-8"
+  }[platform];
+})();
 
 // This function is responsible for taking an input string of text and returning
 // to prettier a JavaScript object that is the equivalent AST that represents

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
@@ -314,7 +314,9 @@ class Prettier::Parser < Ripper
       arg.merge(type: :args, body: [arg])
     else
       args.merge!(
-        body: args[:body] << arg, end: arg[:end], char_end: arg[:char_end]
+        body: args[:body] << arg,
+        end: arg[:end],
+        char_end: arg[:char_end]
       )
     end
   end
@@ -673,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]
@@ -812,18 +821,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(
@@ -979,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)
@@ -1155,6 +1189,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
@@ -1186,7 +1238,8 @@ class Prettier::Parser < Ripper
       # Here we're going to expand out the location information for the assocs
       # node so that it can grab up any remaining comments inside the hash.
       assoclist_from_args.merge!(
-        char_start: beging[:char_end], char_end: ending[:char_start]
+        char_start: beging[:char_end],
+        char_end: ending[:char_start]
       )
     end
 
@@ -1299,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')
 
@@ -1338,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')
@@ -1448,7 +1505,9 @@ class Prettier::Parser < Ripper
       part.merge(type: :mlhs, body: [part])
     else
       mlhs.merge!(
-        body: mlhs[:body] << part, end: part[:end], char_end: part[:char_end]
+        body: mlhs[:body] << part,
+        end: part[:end],
+        char_end: part[:char_end]
       )
     end
   end
@@ -1551,7 +1610,9 @@ class Prettier::Parser < Ripper
       part.merge(type: :mrhs, body: [part])
     else
       mrhs.merge!(
-        body: mrhs[:body] << part, end: part[:end], char_end: part[:char_end]
+        body: mrhs[:body] << part,
+        end: part[:end],
+        char_end: part[:char_end]
       )
     end
   end
@@ -1712,7 +1773,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
@@ -1960,7 +2022,9 @@ class Prettier::Parser < Ripper
   # piece of the string.
   def on_string_add(string, piece)
     string.merge!(
-      body: string[:body] << piece, end: piece[:end], char_end: piece[:char_end]
+      body: string[:body] << piece,
+      end: piece[:end],
+      char_end: piece[:char_end]
     )
   end
 
@@ -2296,7 +2360,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
 
@@ -2417,7 +2481,9 @@ class Prettier::Parser < Ripper
       piece.merge(type: :word, body: [piece])
     else
       word.merge!(
-        body: word[:body] << piece, end: piece[:end], char_end: piece[:char_end]
+        body: word[:body] << piece,
+        end: piece[:end],
+        char_end: piece[:char_end]
       )
     end
   end
@@ -2498,7 +2564,9 @@ class Prettier::Parser < Ripper
     else
       ending = find_scanner_event(:@tstring_end)
       xstring.merge!(
-        type: :xstring_literal, end: ending[:end], char_end: ending[:char_end]
+        type: :xstring_literal,
+        end: ending[:end],
+        char_end: ending[:char_end]
       )
     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",
@@ -83,6 +95,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,57 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.rc2
+  version: 1.2.1
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.13'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
+date: 2020-12-27 00:00:00.000000000 Z
+dependencies: []
 description:
 email:
 executables:
@@ -115,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
@@ -130,11 +89,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language