prettier 1.0.0.pre.rc1 → 1.2.0

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

@@ -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
@@ -566,8 +568,10 @@ class Prettier::Parser < Ripper
 
       # Here we're going to determine the bounds for the stmts
       consequent = parts[1..-1].compact.first
-      self[:body][0].bind(char_start,
-        consequent ? consequent[:char_start] : char_end)
+      self[:body][0].bind(
+        char_start,
+        consequent ? consequent[:char_start] : char_end
+      )
 
       # Next we're going to determine the rescue clause if there is one
       if parts[1]
@@ -810,18 +814,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 there is not a params node, then we have a single-line method
+    unless params
+      return(
+        {
+          type: :defsl,
+          body: [ident, 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(
@@ -1064,7 +1093,10 @@ class Prettier::Parser < Ripper
   # event, so here we'll initialize the current embdoc.
   def on_embdoc_beg(value)
     @embdoc = {
-      type: :@embdoc, value: value, start: lineno, char_start: char_pos
+      type: :@embdoc,
+      value: value,
+      start: lineno,
+      char_start: char_pos
     }
   end
 
@@ -1150,6 +1182,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
@@ -1181,7 +1231,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
 
@@ -1211,9 +1262,12 @@ class Prettier::Parser < Ripper
 
     # Here we're going to artificially create an extra node type so that if
     # there are comments after the declaration of a heredoc, they get printed.
-    location.merge(
-      type: :heredoc, beging: location.merge(type: :@heredoc_beg, body: beging)
-    ).tap { |node| @heredocs << node }
+    location
+      .merge(
+        type: :heredoc,
+        beging: location.merge(type: :@heredoc_beg, body: beging)
+      )
+      .tap { |node| @heredocs << node }
   end
 
   # This is a parser event that occurs when you're using a heredoc with a
@@ -1440,7 +1494,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
@@ -1543,7 +1599,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
@@ -1644,7 +1702,10 @@ class Prettier::Parser < Ripper
   # some found at the end of the source string.
   def on_program(stmts)
     range = {
-      start: 1, end: lines.length, char_start: 0, char_end: source.length
+      start: 1,
+      end: lines.length,
+      char_start: 0,
+      char_end: source.length
     }
 
     stmts[:body] << @__end__ if @__end__
@@ -1701,7 +1762,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
@@ -1949,7 +2011,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
 
@@ -2285,7 +2349,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
 
@@ -2406,7 +2470,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
@@ -2487,7 +2553,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/ruby.js

@@ -76,30 +76,37 @@ module.exports = {
     ruby: printer
   },
   options: {
+    rubyArrayLiteral: {
+      type: "boolean",
+      category: "Ruby",
+      default: true,
+      description:
+        "When possible, favor the use of string and symbol array literals."
+    },
     rubyHashLabel: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When possible, uses the shortened hash key syntax, as opposed to hash rockets."
     },
     rubyModifier: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When it fits on one line, allows if, unless, while, and until statements to use the modifier form."
     },
     rubySingleQuote: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: true,
       description:
         "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals."
     },
     rubyToProc: {
       type: "boolean",
-      category: "Global",
+      category: "Ruby",
       default: false,
       description:
         "When possible, convert blocks to the more concise Symbol#to_proc syntax."

data/src/toProc.js

@@ -11,8 +11,8 @@ const isCall = (node) => ["::", "."].includes(node) || node.type === "@period";
 //     [1, 2, 3].map(&:to_s)
 //
 // This works with `do` blocks as well.
-const toProc = (path, opts, node) => {
-  if (!node || !opts.rubyToProc) {
+const toProc = (path, node) => {
+  if (!node) {
     return null;
   }
 

data/src/utils.js

@@ -1,8 +1,7 @@
 const { concat } = require("./prettier");
 const isEmptyStmts = require("./utils/isEmptyStmts");
 const literalLineNoBreak = require("./utils/literalLineNoBreak");
-
-const concatBody = (path, opts, print) => concat(path.map(print, "body"));
+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.
@@ -79,7 +78,6 @@ const skipAssignIndent = (node) =>
   (node.type === "call" && skipAssignIndent(node.body[0]));
 
 module.exports = {
-  concatBody,
   containsAssignment,
   docLength,
   empty,
@@ -92,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.rc1
+  version: 1.2.0
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-09 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-26 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