prettier 0.20.1 → 0.21.0

data/src/nodes/loops.js

@@ -7,7 +7,9 @@ const {
   indent,
   softline
 } = require("../prettier");
+
 const { containsAssignment } = require("../utils");
+const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
 const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
   const [_predicate, statements] = path.getValue().body;
@@ -26,30 +28,13 @@ const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
     );
   }
 
-  let inlineParts = [
-    path.call(print, "body", 1),
-    ` ${keyword} `,
-    path.call(print, "body", 0)
-  ];
-
-  // If the return value of this loop expression is being assigned to anything
-  // besides a local variable then we can't inline the entire expression
-  // without wrapping it in parentheses. This is because the following
-  // expressions have different semantic meaning:
-  //
-  //     hash[:key] = break :value while false
-  //     hash[:key] = while false do break :value end
-  //
-  // The first one will not result in an empty hash, whereas the second one
-  // will result in `{ key: nil }`. In this case what we need to do for the
-  // first expression to align is wrap it in parens, as in:
-  //
-  //     hash[:key] = (break :value while false)
-  if (["assign", "massign"].includes(path.getParentNode().type)) {
-    inlineParts = ["("].concat(inlineParts).concat(")");
-  }
-
-  const inlineLoop = concat(inlineParts);
+  const inlineLoop = concat(
+    inlineEnsureParens(path, [
+      path.call(print, "body", 1),
+      ` ${keyword} `,
+      path.call(print, "body", 0)
+    ])
+  );
 
   // If we're in the modifier form and we're modifying a `begin`, then this is a
   // special case where we need to explicitly use the modifier form because

data/src/nodes/strings.js

@@ -133,12 +133,6 @@ module.exports = {
     const stringLiteral = path.getValue();
     const string = stringLiteral.body[0];
 
-    // If this string is actually a heredoc, bail out and return to the print
-    // function for heredocs
-    if (string.type === "heredoc") {
-      return path.call(print, "body", 0);
-    }
-
     // If the string is empty, it will not have any parts, so just print out the
     // quotes corresponding to the config
     if (string.body.length === 0) {

data/src/parse.js

@@ -19,7 +19,7 @@ const LANG = {
 module.exports = (text, _parsers, _opts) => {
   const child = spawnSync(
     "ruby",
-    ["--disable-gems", path.join(__dirname, "./ripper.rb")],
+    ["--disable-gems", path.join(__dirname, "./parser.rb")],
     {
       env: Object.assign({}, process.env, { LANG }),
       input: text,

data/src/{ripper.rb → parser.rb}

@@ -16,7 +16,9 @@ end
 require 'json' unless defined?(JSON)
 require 'ripper'
 
-class RipperJS < Ripper
+module Prettier; end
+
+class Prettier::Parser < Ripper
   attr_reader :source, :lines, :__end__
 
   def initialize(source, *args)
@@ -476,7 +478,7 @@ class RipperJS < Ripper
       def on_comment(body)
         sexp = { type: :@comment, body: body.chomp, start: lineno, end: lineno }
 
-        case RipperJS.lex_state_name(state).gsub('EXPR_', '')
+        case Prettier::Parser.lex_state_name(state).gsub('EXPR_', '')
         when 'END', 'ARG|LABELED', 'ENDFN'
           last_sexp.merge!(comments: [sexp])
         when 'CMDARG', 'END|ENDARG', 'ENDARG', 'ARG', 'FNAME|FITEM', 'CLASS',
@@ -565,7 +567,7 @@ class RipperJS < Ripper
 
       def on_comment(body)
         super(body).tap do |sexp|
-          lex_state = RipperJS.lex_state_name(state).gsub('EXPR_', '')
+          lex_state = Prettier::Parser.lex_state_name(state).gsub('EXPR_', '')
           block_comments << sexp if lex_state == 'BEG'
         end
       end
@@ -614,34 +616,39 @@ class RipperJS < Ripper
 
       private
 
-      def on_embexpr_beg(body)
-        super(body).tap { |sexp| heredoc_stack << sexp }
-      end
-
-      def on_embexpr_end(body)
-        super(body).tap { heredoc_stack.pop }
-      end
-
+      # This is a scanner event that represents the beginning of the heredoc.
       def on_heredoc_beg(beging)
-        heredoc = { type: :heredoc, beging: beging, start: lineno, end: lineno }
-        heredoc_stack << heredoc
+        {
+          type: :heredoc,
+          beging: beging,
+          start: lineno,
+          end: lineno,
+          char_start: char_pos - beging.length + 1,
+          char_end: char_pos
+        }.tap { |node| heredoc_stack << node }
       end
 
+      # This is a scanner event that represents the end of the heredoc.
       def on_heredoc_end(ending)
-        heredoc_stack[-1].merge!(ending: ending.chomp, end: lineno)
+        heredoc_stack[-1].merge!(
+          ending: ending.chomp, end: lineno, char_end: char_pos
+        )
       end
 
+      # This is a parser event that occurs when you're using a heredoc with a
+      # tilde. These are considered `heredoc_dedent` nodes, whereas the hyphen
+      # heredocs show up as string literals.
       def on_heredoc_dedent(string, _width)
-        heredoc = heredoc_stack.pop
-        string.merge!(heredoc.slice(:type, :beging, :ending, :start, :end))
+        heredoc_stack[-1].merge!(string.slice(:body))
       end
 
+      # String literals are either going to be a normal string or they're going
+      # to be a heredoc with a hyphen.
       def on_string_literal(string)
         heredoc = heredoc_stack[-1]
 
-        if heredoc && string[:type] != :heredoc && heredoc[:type] == :heredoc
-          heredoc_stack.pop
-          string.merge!(heredoc.slice(:type, :beging, :ending, :start, :end))
+        if heredoc && heredoc[:ending]
+          heredoc_stack.pop.merge!(string.slice(:body))
         else
           super
         end
@@ -731,36 +738,6 @@ class RipperJS < Ripper
         super(ident, params, def_bodystmt)
       end
 
-      # By default, Ripper parses the expression `lambda { foo }` as a
-      # `method_add_block` node, so we can't turn it back into `-> { foo }`.
-      # This module overrides that behavior and reports it back as a `lambda`
-      # node instead.
-      def on_method_add_block(invocation, block)
-        # It's possible to hit a `method_add_block` node without going through
-        # `method_add_arg` node, ex: `super {}`. In that case we're definitely
-        # not going to transform into a lambda.
-        return super if invocation[:type] != :method_add_arg
-
-        fcall, args = invocation[:body]
-
-        # If there are arguments to the `lambda`, that means `lambda` has been
-        # overridden as a function so we cannot transform it into a `lambda`
-        # node.
-        if fcall[:type] != :fcall || args[:type] != :args || args[:body].any?
-          return super
-        end
-
-        ident = fcall.dig(:body, 0)
-        return super if ident[:type] != :@ident || ident[:body] != 'lambda'
-
-        super.tap do |sexp|
-          params, stmts = block[:body]
-          params ||= { type: :params, body: [] }
-
-          sexp.merge!(type: :lambda, body: [params, stmts])
-        end
-      end
-
       # We need to track for `mlhs_paren` and `massign` nodes whether or not
       # there was an extra comma at the end of the expression. For some reason
       # it's not showing up in the AST in an obvious way. In this case we're
@@ -794,7 +771,7 @@ end
 # stdin and report back the AST over stdout.
 
 if $0 == __FILE__
-  builder = RipperJS.new($stdin.read)
+  builder = Prettier::Parser.new($stdin.read)
   response = builder.parse
 
   if !response || builder.error?

data/src/ruby.js

@@ -130,7 +130,7 @@ module.exports = {
     toProcTransform: {
       type: "boolean",
       category: "Global",
-      default: true,
+      default: false,
       description:
         "When possible, convert blocks to the more concise Symbol#to_proc syntax."
     }

data/src/utils.js

@@ -5,6 +5,7 @@ const {
   lineSuffix,
   literalline
 } = require("./prettier");
+const isEmptyStmts = require("./utils/isEmptyStmts");
 
 const concatBody = (path, opts, print) => concat(path.map(print, "body"));
 
@@ -65,27 +66,16 @@ const makeArgs = (path, opts, print, argsIndex) => {
   const heredocs = [];
 
   argNodes.body.forEach((argNode, index) => {
-    let pattern;
-    let heredoc;
-
     if (argNode.type === "heredoc") {
-      pattern = [index, "body"];
-      heredoc = argNode;
-    } else if (
-      argNode.type === "string_literal" &&
-      argNode.body[0].type === "heredoc"
-    ) {
-      pattern = [index, "body", 0, "body"];
-      [heredoc] = argNode.body;
-    } else {
-      return;
+      const content = path.map.apply(
+        path,
+        argPattern.slice().concat([index, "body"])
+      );
+      heredocs.push(
+        concat([literalline].concat(content).concat([argNode.ending]))
+      );
+      args[index] = argNode.beging;
     }
-
-    const content = path.map.apply(path, argPattern.slice().concat(pattern));
-    heredocs.push(
-      concat([literalline].concat(content).concat([heredoc.ending]))
-    );
-    args[index] = heredoc.beging;
   });
 
   return { args, heredocs };
@@ -103,6 +93,16 @@ const makeCall = (path, opts, print) => {
 
 const makeList = (path, opts, print) => path.map(print, "body");
 
+const nodeDive = (node, steps) => {
+  let current = node;
+
+  steps.forEach((step) => {
+    current = current[step];
+  });
+
+  return current;
+};
+
 const prefix = (value) => (path, opts, print) =>
   concat([value, path.call(print, "body", 0)]);
 
@@ -146,10 +146,12 @@ module.exports = {
   empty,
   first,
   hasAncestor,
+  isEmptyStmts,
   literal,
   makeArgs,
   makeCall,
   makeList,
+  nodeDive,
   prefix,
   printComments,
   skipAssignIndent,

data/src/utils/inlineEnsureParens.js

@@ -0,0 +1,42 @@
+const needsParens = ["args", "assign", "assoc_new", "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
+// in parentheses. This occurs when you have something like:
+//
+//     foo[:foo] =
+//       if bar?
+//         baz
+//       end
+//
+// Normally we would shorten this to an inline version, which would result in:
+//
+//     foo[:foo] = baz if bar?
+//
+// but this actually has different semantic meaning. The first example will
+// result in a nil being inserted into the hash for the :foo key, whereas the
+// second example will result in an empty hash because the if statement applies
+// to the entire assignment.
+//
+// We can fix this in a couple of ways. We can use the then keyword, as in:
+//
+//     foo[:foo] = if bar? then baz end
+//
+// but I haven't actually seen this anywhere. We can also just leave it as is
+// with the multi-line version, but for a short predicate and short value it
+// looks pretty silly. The last option and the one I've selected here is to add
+// parentheses on both sides of the expression, as in:
+//
+//     foo[:foo] = (baz if bar?)
+//
+// This approach maintains the nice conciseness of the inline version, while
+// keeping the correct semantic meaning.
+const inlineEnsureParens = (path, parts) => {
+  if (needsParens.includes(path.getParentNode().type)) {
+    return ["("].concat(parts, ")");
+  }
+
+  return parts;
+};
+
+module.exports = inlineEnsureParens;

data/src/utils/isEmptyStmts.js

@@ -0,0 +1,7 @@
+const isEmptyStmts = (node) =>
+  node &&
+  node.type === "stmts" &&
+  node.body.length === 1 &&
+  node.body[0].type === "void_stmt";
+
+module.exports = isEmptyStmts;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 0.20.1
+  version: 0.21.0
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-04 00:00:00.000000000 Z
+date: 2020-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,7 @@ files:
 - src/embed.js
 - src/nodes.js
 - src/nodes/alias.js
+- src/nodes/aref.js
 - src/nodes/args.js
 - src/nodes/arrays.js
 - src/nodes/assign.js
@@ -102,12 +103,14 @@ files:
 - src/nodes/statements.js
 - src/nodes/strings.js
 - src/parse.js
+- src/parser.rb
 - src/prettier.js
 - src/print.js
-- src/ripper.rb
 - src/ruby.js
 - src/toProc.js
 - src/utils.js
+- src/utils/inlineEnsureParens.js
+- src/utils/isEmptyStmts.js
 homepage: https://github.com/prettier/plugin-ruby#readme
 licenses:
 - MIT