prettier 0.22.0 → 1.0.0.pre.rc1

data/src/nodes/methods.js

@@ -28,7 +28,9 @@ function printMethod(offset) {
 
     // 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

data/src/nodes/operators.js

@@ -1,23 +1,34 @@
 const { concat, group, indent, line, softline } = require("../prettier");
+const { noIndent } = require("../utils");
 
 function printBinary(path, opts, print) {
-  const operator = path.getValue().body[1];
-  const useNoSpace = operator === "**";
+  const [_leftNode, operator, rightNode] = path.getValue().body;
+  const space = operator === "**" ? "" : " ";
+
+  if (noIndent.includes(rightNode.type)) {
+    return group(
+      concat([
+        group(path.call(print, "body", 0)),
+        space,
+        operator,
+        space,
+        group(path.call(print, "body", 2))
+      ])
+    );
+  }
 
   return group(
     concat([
       group(path.call(print, "body", 0)),
-      indent(
-        concat([
-          useNoSpace ? "" : " ",
-          group(
-            concat([
-              operator,
-              useNoSpace ? softline : line,
-              path.call(print, "body", 2)
-            ])
-          )
-        ])
+      space,
+      group(
+        indent(
+          concat([
+            operator,
+            space === "" ? softline : line,
+            path.call(print, "body", 2)
+          ])
+        )
       )
     ])
   );

data/src/nodes/regexp.js

@@ -1,5 +1,24 @@
 const { concat } = require("../prettier");
 
+function isStringContent(node) {
+  return node.type === "@tstring_content";
+}
+
+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;
+  }
+
+  return node.body.some(
+    (child) => isStringContent(child) && child.body.includes("/")
+  );
+}
+
 // This function is responsible for printing out regexp_literal nodes. They can
 // either use the special %r literal syntax or they can use forward slashes. At
 // the end of either of those they can have modifiers like m or x that have
@@ -8,16 +27,12 @@ const { concat } = require("../prettier");
 // We favor the use of forward slashes unless the regex contains a forward slash
 // itself. In that case we switch over to using %r with braces.
 function printRegexpLiteral(path, opts, print) {
-  const { ending } = path.getValue();
-  const contents = path.map(print, "body");
-
-  const useBraces = contents.some(
-    (content) => typeof content === "string" && content.includes("/")
-  );
+  const node = path.getValue();
+  const useBraces = shouldUseBraces(node);
 
   const parts = [useBraces ? "%r{" : "/"]
-    .concat(contents)
-    .concat([useBraces ? "}" : "/", ending.slice(1)]);
+    .concat(path.map(print, "body"))
+    .concat([useBraces ? "}" : "/", node.ending.slice(1)]);
 
   return concat(parts);
 }

data/src/nodes/rescue.js

@@ -20,8 +20,8 @@ function printBegin(path, opts, print) {
 
 function printEnsure(path, opts, print) {
   return concat([
-    "ensure",
-    indent(concat([hardline, concat(path.map(print, "body"))]))
+    path.call(print, "body", 0),
+    indent(concat([hardline, path.call(print, "body", 1)]))
   ]);
 }
 

data/src/nodes/statements.js

@@ -12,35 +12,45 @@ const {
   trim
 } = require("../prettier");
 
-module.exports = {
-  "@__end__": (path, _opts, _print) => {
-    const { body } = path.getValue();
-    return concat([trim, "__END__", literalline, body]);
-  },
-  bodystmt: (path, opts, print) => {
-    const [_statements, rescue, elseClause, ensure] = path.getValue().body;
-    const parts = [path.call(print, "body", 0)];
+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
+  ) {
+    parts.push(path.call(print, "body", 0));
+  }
 
-    if (rescue) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
-    }
+  if (rescue) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 1)])));
+  }
 
-    if (elseClause) {
-      // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
-      const stmts =
-        elseClause.type === "else"
-          ? path.call(print, "body", 2, "body", 0)
-          : path.call(print, "body", 2);
+  if (elseClause) {
+    // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+    const stmts =
+      elseClause.type === "else"
+        ? path.call(print, "body", 2, "body", 0)
+        : path.call(print, "body", 2);
 
-      parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
-    }
+    parts.push(concat([dedent(concat([hardline, "else"])), hardline, stmts]));
+  }
 
-    if (ensure) {
-      parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
-    }
+  if (ensure) {
+    parts.push(dedent(concat([hardline, path.call(print, "body", 3)])));
+  }
+
+  return group(concat(parts));
+}
 
-    return group(concat(parts));
+module.exports = {
+  "@__end__": (path, _opts, _print) => {
+    const { body } = path.getValue();
+    return concat([trim, "__END__", literalline, body]);
   },
+  bodystmt: printBodyStmt,
   paren: (path, opts, print) => {
     if (!path.getValue().body[0]) {
       return "()";

data/src/nodes/strings.js

@@ -66,7 +66,7 @@ function getClosingQuote(quote) {
     return quote;
   }
 
-  const boundary = /%q?(.)/.exec(quote)[1];
+  const boundary = /%[Qq]?(.)/.exec(quote)[1];
   if (boundary in quotePairs) {
     return quotePairs[boundary];
   }
@@ -77,14 +77,14 @@ function getClosingQuote(quote) {
 // Prints a @CHAR node. @CHAR nodes are special character strings that usually
 // are strings of length 1. If they're any longer than we'll try to apply the
 // correct quotes.
-function printChar(path, { preferSingleQuotes }, _print) {
+function printChar(path, { rubySingleQuote }, _print) {
   const { body } = path.getValue();
 
   if (body.length !== 2) {
     return body;
   }
 
-  const quote = preferSingleQuotes ? "'" : '"';
+  const quote = rubySingleQuote ? "'" : '"';
   return concat([quote, body.slice(1), quote]);
 }
 
@@ -107,13 +107,13 @@ function printStringDVar(path, opts, print) {
 // wishes of the user with regards to single versus double quotes, but if the
 // string contains any escape expressions then it will just keep the original
 // quotes.
-function printStringLiteral(path, { preferSingleQuotes }, print) {
+function printStringLiteral(path, { rubySingleQuote }, print) {
   const node = path.getValue();
 
   // If the string is empty, it will not have any parts, so just print out the
   // quotes corresponding to the config
   if (node.body.length === 0) {
-    return preferSingleQuotes ? "''" : '""';
+    return rubySingleQuote ? "''" : '""';
   }
 
   // Determine the quote that should enclose the new string
@@ -121,7 +121,7 @@ function printStringLiteral(path, { preferSingleQuotes }, print) {
   if (isQuoteLocked(node)) {
     quote = node.quote;
   } else {
-    quote = preferSingleQuotes && isSingleQuotable(node) ? "'" : '"';
+    quote = rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
   }
 
   const parts = node.body.map((part, index) => {
@@ -167,10 +167,11 @@ module.exports = {
   string_embexpr: (path, opts, print) => {
     const parts = path.call(print, "body", 0);
 
-    // If the interpolated expression is inside of an xstring literal (a string
-    // that gets sent to the command line) then we don't want to automatically
-    // indent, as this can lead to some very odd looking expressions
-    if (path.getParentNode().type === "xstring_literal") {
+    // If the interpolated expression is inside of a heredoc or an xstring
+    // literal (a string that gets sent to the command line) then we don't want
+    // to automatically indent, as this can lead to some very odd looking
+    // expressions
+    if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
       return concat(["#{", parts, "}"]);
     }
 

data/src/parser.rb

@@ -2,7 +2,7 @@
 
 # We implement our own version checking here instead of using Gem::Version so
 # that we can use the --disable-gems flag.
-RUBY_MAJOR, RUBY_MINOR, * = RUBY_VERSION.split('.').map(&:to_i)
+RUBY_MAJOR, RUBY_MINOR, RUBY_PATCH, * = RUBY_VERSION.split('.').map(&:to_i)
 
 if (RUBY_MAJOR < 2) || ((RUBY_MAJOR == 2) && (RUBY_MINOR < 5))
   warn(
@@ -115,15 +115,14 @@ class Prettier::Parser < Ripper
   # This will break everything, so we need to force the encoding back into
   # UTF-8 so that the JSON library won't break.
   def on_comment(value)
-    @comments <<
-      {
-        type: :@comment,
-        value: value[1..-1].chomp.force_encoding('UTF-8'),
-        start: lineno,
-        end: lineno,
-        char_start: char_pos,
-        char_end: char_pos + value.length - 1
-      }
+    @comments << {
+      type: :@comment,
+      value: value[1..-1].chomp.force_encoding('UTF-8'),
+      start: lineno,
+      end: lineno,
+      char_start: char_pos,
+      char_end: char_pos + value.length - 1
+    }
   end
 
   # ignored_nl is a special kind of scanner event that passes nil as the value,
@@ -187,11 +186,14 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
     find_scanner_event(:@kw, 'BEGIN').merge!(
       type: :BEGIN,
-      body: [stmts],
+      body: [beging, stmts],
       end: ending[:end],
       char_end: ending[:char_end]
     )
@@ -211,10 +213,16 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
     find_scanner_event(:@kw, 'END').merge!(
-      type: :END, body: [stmts], end: ending[:end], char_end: ending[:char_end]
+      type: :END,
+      body: [beging, stmts],
+      end: ending[:end],
+      char_end: ending[:char_end]
     )
   end
 
@@ -352,7 +360,12 @@ class Prettier::Parser < Ripper
   # method inside a set of parentheses.
   def on_arg_paren(args)
     beging = find_scanner_event(:@lparen)
-    ending = find_scanner_event(:@rparen)
+    rparen = find_scanner_event(:@rparen)
+
+    # If the arguments exceed the ending of the parentheses, then we know we
+    # have a heredoc in the arguments, and we need to use the bounds of the
+    # arguments to determine how large the arg_paren is.
+    ending = (args && args[:end] > rparen[:end]) ? args : rparen
 
     {
       type: :arg_paren,
@@ -559,7 +572,7 @@ class Prettier::Parser < Ripper
       # Next we're going to determine the rescue clause if there is one
       if parts[1]
         consequent = parts[2..-1].compact.first
-        self[:body][1].bind(consequent ? consequent[:char_start] : char_end)
+        self[:body][1].bind_end(consequent ? consequent[:char_start] : char_end)
       end
     end
   end
@@ -601,7 +614,16 @@ class Prettier::Parser < Ripper
   # accepts as an argument an args or args_add_block event that contains all
   # of the arguments being passed to the break.
   def on_break(args_add_block)
-    find_scanner_event(:@kw, 'break').merge!(
+    beging = find_scanner_event(:@kw, 'break')
+
+    # You can hit this if you are passing no arguments to break but it has a
+    # comment right after it. In that case we can just use the location
+    # information straight from the keyword.
+    if args_add_block[:type] == :args
+      return beging.merge!(type: :break, body: [args_add_block])
+    end
+
+    beging.merge!(
       type: :break,
       body: [args_add_block],
       end: args_add_block[:end],
@@ -621,6 +643,10 @@ class Prettier::Parser < Ripper
   #     foo.(1, 2, 3)
   #
   def on_call(receiver, oper, sending)
+    # Make sure we take the operator out of the scanner events so that it
+    # doesn't get confused for a unary operator later.
+    scanner_events.delete(oper)
+
     ending = sending
 
     if sending == :call
@@ -653,6 +679,27 @@ class Prettier::Parser < Ripper
     )
   end
 
+  # Finds the next position in the source string that begins a statement. This
+  # is used to bind statements lists and make sure they don't include a
+  # preceding comment. For example, we want the following comment to be attached
+  # to the class node and not the statement node:
+  #
+  #     class Foo # :nodoc:
+  #       ...
+  #     end
+  #
+  # By finding the next non-space character, we can make sure that the bounds of
+  # the statement list are correct.
+  def find_next_statement_start(position)
+    remaining = source[position..-1]
+
+    if remaining.sub(/\A +/, '')[0] == '#'
+      return position + remaining.index("\n")
+    end
+
+    position
+  end
+
   # class is a parser event that represents defining a class. It accepts as
   # arguments the name of the class, the optional name of the superclass,
   # and the bodystmt event that represents the statements evaluated within
@@ -661,7 +708,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'class')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind((superclass || const)[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start((superclass || const)[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :class,
@@ -761,6 +811,11 @@ class Prettier::Parser < Ripper
   #          └> 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)
+
     if params[:type] == :params && !params[:body].any?
       location = ident[:char_end]
       params.merge!(char_start: location, char_end: location)
@@ -769,7 +824,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'def')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(params[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :def,
@@ -796,6 +854,11 @@ class Prettier::Parser < Ripper
   #          └> target
   #
   def on_defs(target, oper, 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)
+
     if params[:type] == :params && !params[:body].any?
       location = ident[:char_end]
       params.merge!(char_start: location, char_end: location)
@@ -804,7 +867,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'def')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(params[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(params[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :defs,
@@ -1029,13 +1095,23 @@ class Prettier::Parser < Ripper
   # and its subsequent statements.
   def on_ensure(stmts)
     beging = find_scanner_event(:@kw, 'ensure')
-    ending = find_scanner_event(:@kw, 'end')
 
-    stmts.bind(beging[:char_end], ending[:char_start])
+    # Specifically not using find_scanner_event here because we don't want to
+    # consume the :@end event, because that would break def..ensure..end chains.
+    index =
+      scanner_events.rindex do |scanner_event|
+        scanner_event[:type] == :@kw && scanner_event[:body] == 'end'
+      end
+
+    ending = scanner_events[index]
+    stmts.bind(
+      find_next_statement_start(beging[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :ensure,
-      body: [stmts],
+      body: [beging, stmts],
       start: beging[:start],
       char_start: beging[:char_start],
       end: ending[:end],
@@ -1126,21 +1202,25 @@ class Prettier::Parser < Ripper
   # prettier parser, we'll later attempt to print it using that parser and
   # printer through our embed function.
   def on_heredoc_beg(beging)
-    {
-      type: :heredoc,
-      beging: beging,
+    location = {
       start: lineno,
       end: lineno,
-      char_start: char_pos - beging.length + 1,
-      char_end: char_pos
-    }.tap { |node| @heredocs << node }
+      char_start: char_pos,
+      char_end: char_pos + beging.length + 1
+    }
+
+    # 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 }
   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)
-    @heredocs[-1].merge!(string.slice(:body))
+    @heredocs[-1].merge!(body: string[:body])
   end
 
   # This is a scanner event that represents the end of the heredoc.
@@ -1306,6 +1386,14 @@ class Prettier::Parser < Ripper
   # arguments and parentheses. It accepts as arguments the method being called
   # and the arg_paren event that contains the arguments to the method.
   def on_method_add_arg(fcall, arg_paren)
+    # You can hit this if you are passing no arguments to a method that ends in
+    # a question mark. Because it knows it has to be a method and not a local
+    # variable. In that case we can just use the location information straight
+    # from the fcall.
+    if arg_paren[:type] == :args
+      return fcall.merge(type: :method_add_arg, body: [fcall, arg_paren])
+    end
+
     {
       type: :method_add_arg,
       body: [fcall, arg_paren],
@@ -1418,7 +1506,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'module')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(const[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(const[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :module,
@@ -1643,17 +1734,17 @@ class Prettier::Parser < Ripper
   # determine its ending. Therefore it relies on its parent bodystmt node to
   # report its ending to it.
   class Rescue < SimpleDelegator
-    def bind(char_end)
+    def bind_end(char_end)
       merge!(char_end: char_end)
 
       stmts = self[:body][2]
       consequent = self[:body][3]
 
       if consequent
-        consequent.bind(char_end)
-        stmts.bind(stmts[:char_start], consequent[:char_start])
+        consequent.bind_end(char_end)
+        stmts.bind_end(consequent[:char_start])
       else
-        stmts.bind(stmts[:char_start], char_end)
+        stmts.bind_end(char_end)
       end
     end
   end
@@ -1663,10 +1754,10 @@ class Prettier::Parser < Ripper
   def on_rescue(exceptions, variable, stmts, consequent)
     beging = find_scanner_event(:@kw, 'rescue')
 
-    stmts.bind(
-      ((exceptions || [])[-1] || variable || beging)[:char_end],
-      char_pos
-    )
+    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
+    last_node = variable || last_exception || beging
+
+    stmts.bind(find_next_statement_start(last_node[:char_end]), char_pos)
 
     Rescue.new(
       beging.merge!(
@@ -1750,7 +1841,10 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'class')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind(target[:char_end], ending[:char_start])
+    bodystmt.bind(
+      find_next_statement_start(target[:char_end]),
+      ending[:char_start]
+    )
 
     {
       type: :sclass,
@@ -1778,6 +1872,10 @@ class Prettier::Parser < Ripper
       end
     end
 
+    def bind_end(char_end)
+      merge!(char_end: char_end)
+    end
+
     def <<(statement)
       if self[:body].any?
         merge!(statement.slice(:end, :char_end))
@@ -1948,7 +2046,7 @@ class Prettier::Parser < Ripper
   # symbol node (for most cases) or an ident node (in the case that we're
   # using bare words, as in an alias node like alias foo bar).
   def on_symbol_literal(contents)
-    if contents[:type] == :@ident
+    if scanner_events[-1] == contents
       contents.merge(type: :symbol_literal, body: [contents])
     else
       beging = find_scanner_event(:@symbeg)
@@ -2042,7 +2140,18 @@ class Prettier::Parser < Ripper
         paren: paren
       )
     else
-      find_scanner_event(:@op).merge!(
+      # Special case instead of using find_scanner_event here. It turns out that
+      # if you have a range that goes from a negative number to a negative
+      # number then you can end up with a .. or a ... that's higher in the
+      # stack. So we need to explicitly disallow those operators.
+      index =
+        scanner_events.rindex do |scanner_event|
+          scanner_event[:type] == :@op &&
+            !%w[.. ...].include?(scanner_event[:body])
+        end
+
+      beging = scanner_events.delete_at(index)
+      beging.merge!(
         type: :unary,
         oper: oper[0],
         body: [value],
@@ -2335,6 +2444,8 @@ class Prettier::Parser < Ripper
 
     if heredoc && heredoc[:beging][3] = '`'
       heredoc.merge(type: :xstring, body: [])
+    elsif RUBY_MAJOR <= 2 && RUBY_MINOR <= 5 && RUBY_PATCH < 7
+      { type: :xstring, body: [] }
     else
       find_scanner_event(:@backtick).merge!(type: :xstring, body: [])
     end