prettier 1.5.1 → 1.6.0

data/src/ruby/nodes/calls.js

@@ -4,6 +4,7 @@ const {
   hardline,
   ifBreak,
   indent,
+  join,
   softline
 } = require("../../prettier");
 const { makeCall, noIndent } = require("../../utils");
@@ -133,7 +134,13 @@ function printMethodAddArg(path, opts, print) {
     );
   }
 
-  return concat([methodDoc, argsDoc]);
+  // If there are already parentheses, then we can just use the doc that's
+  // already printed.
+  if (argNode.type == "arg_paren") {
+    return concat([methodDoc, argsDoc]);
+  }
+
+  return concat([methodDoc, " ", join(", ", argsDoc), " "]);
 }
 
 function printMethodAddBlock(path, opts, print) {

data/src/ruby/nodes/conditionals.js

@@ -190,57 +190,59 @@ const canTernary = (path) => {
 };
 
 // A normalized print function for both `if` and `unless` nodes.
-const printConditional = (keyword) => (path, { rubyModifier }, print) => {
-  if (canTernary(path)) {
-    let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
-      printTernaryClauses(
-        keyword,
-        path.call(print, "body", 1),
-        path.call(print, "body", 2, "body", 0)
-      )
-    );
-
-    if (["binary", "call"].includes(path.getParentNode().type)) {
-      ternaryParts = ["("].concat(ternaryParts).concat(")");
+const printConditional =
+  (keyword) =>
+  (path, { rubyModifier }, print) => {
+    if (canTernary(path)) {
+      let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
+        printTernaryClauses(
+          keyword,
+          path.call(print, "body", 1),
+          path.call(print, "body", 2, "body", 0)
+        )
+      );
+
+      if (["binary", "call"].includes(path.getParentNode().type)) {
+        ternaryParts = ["("].concat(ternaryParts).concat(")");
+      }
+
+      return group(
+        ifBreak(printWithAddition(keyword, path, print), concat(ternaryParts))
+      );
     }
 
-    return group(
-      ifBreak(printWithAddition(keyword, path, print), concat(ternaryParts))
-    );
-  }
-
-  const [predicate, statements, addition] = path.getValue().body;
+    const [predicate, statements, addition] = path.getValue().body;
 
-  // If there's an additional clause that wasn't matched earlier, we know we
-  // can't go for the inline option.
-  if (addition) {
-    return group(printWithAddition(keyword, path, print, { breaking: true }));
-  }
+    // If there's an additional clause that wasn't matched earlier, we know we
+    // can't go for the inline option.
+    if (addition) {
+      return group(printWithAddition(keyword, path, print, { breaking: true }));
+    }
 
-  // If the body of the conditional is empty, then we explicitly have to use the
-  // block form.
-  if (isEmptyStmts(statements)) {
-    return concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0)),
-      concat([hardline, "end"])
-    ]);
-  }
+    // If the body of the conditional is empty, then we explicitly have to use the
+    // block form.
+    if (isEmptyStmts(statements)) {
+      return concat([
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0)),
+        concat([hardline, "end"])
+      ]);
+    }
 
-  // If the predicate of the conditional contains an assignment, then we can't
-  // know for sure that it doesn't impact the body of the conditional, so we
-  // have to default to the block form.
-  if (containsAssignment(predicate)) {
-    return concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0)),
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      concat([hardline, "end"])
-    ]);
-  }
+    // If the predicate of the conditional contains an assignment, then we can't
+    // know for sure that it doesn't impact the body of the conditional, so we
+    // have to default to the block form.
+    if (containsAssignment(predicate)) {
+      return concat([
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0)),
+        indent(concat([hardline, path.call(print, "body", 1)])),
+        concat([hardline, "end"])
+      ]);
+    }
 
-  return printSingle(keyword)(path, { rubyModifier }, print);
-};
+    return printSingle(keyword)(path, { rubyModifier }, print);
+  };
 
 module.exports = {
   else: (path, opts, print) => {

data/src/ruby/nodes/hashes.js

@@ -56,28 +56,19 @@ function printHashKeyLabel(path, print) {
     case "symbol_literal":
       return concat([path.call(print, "body", 0), ":"]);
     case "dyna_symbol": {
-      const { parts } = print(path);
-
-      // We're going to slice off the starting colon character so that we can
-      // move it to the end. If there are comments, then we're going to go
-      // further into the printed doc nodes.
-      if (parts[0] === ":") {
-        parts.splice(0, 1);
-      } else {
-        parts[1].parts.splice(0, 1);
-      }
-
-      return concat(parts.concat(":"));
+      return concat([print(path), ":"]);
     }
   }
 }
 
 function printHashKeyRocket(path, print) {
   const node = path.getValue();
-  const doc = print(path);
+  let doc = print(path);
 
   if (node.type === "@label") {
-    return `:${doc.slice(0, doc.length - 1)} =>`;
+    doc = concat([":", doc.slice(0, doc.length - 1)]);
+  } else if (node.type === "dyna_symbol") {
+    doc = concat([":", doc]);
   }
 
   return concat([doc, " =>"]);

data/src/ruby/nodes/heredocs.js

@@ -1,5 +1,5 @@
 const { concat, group, lineSuffix, join } = require("../../prettier");
-const { literalLineNoBreak } = require("../../utils");
+const { literallineWithoutBreakParent } = require("../../utils");
 
 function printHeredoc(path, opts, print) {
   const { body, ending } = path.getValue();
@@ -11,7 +11,7 @@ function printHeredoc(path, opts, print) {
     }
 
     // In this case, the part of the string is just regular string content
-    return join(literalLineNoBreak, part.body.split("\n"));
+    return join(literallineWithoutBreakParent, part.body.split("\n"));
   });
 
   // We use a literalline break because matching indentation is required
@@ -23,7 +23,9 @@ function printHeredoc(path, opts, print) {
     concat([
       path.call(print, "beging"),
       lineSuffix(
-        group(concat([literalLineNoBreak].concat(parts).concat(ending)))
+        group(
+          concat([literallineWithoutBreakParent].concat(parts).concat(ending))
+        )
       )
     ])
   );

data/src/ruby/nodes/params.js

@@ -17,15 +17,8 @@ function printRestParam(symbol) {
 }
 
 function printParams(path, opts, print) {
-  const [
-    reqs,
-    optls,
-    rest,
-    post,
-    kwargs,
-    kwargRest,
-    block
-  ] = path.getValue().body;
+  const [reqs, optls, rest, post, kwargs, kwargRest, block] =
+    path.getValue().body;
   let parts = [];
 
   if (reqs) {

data/src/ruby/nodes/strings.js

@@ -82,13 +82,106 @@ function printChar(path, { rubySingleQuote }, _print) {
   return concat([quote, body.slice(1), quote]);
 }
 
+function printPercentSDynaSymbol(path, opts, print) {
+  const node = path.getValue();
+  const parts = [];
+
+  // Push on the quote, which includes the opening character.
+  parts.push(node.quote);
+
+  path.each((childPath) => {
+    const childNode = childPath.getValue();
+
+    if (childNode.type !== "@tstring_content") {
+      // Here we are printing an embedded variable or expression.
+      parts.push(print(childPath));
+    } else {
+      // Here we are printing plain string content.
+      parts.push(join(literalline, childNode.body.split("\n")));
+    }
+  }, "body");
+
+  // Push on the closing character, which is the opposite of the third
+  // character from the opening.
+  parts.push(quotePairs[node.quote[2]]);
+
+  return concat(parts);
+}
+
+// We don't actually want to print %s symbols, as they're much more rarely seen
+// in the wild. But we're going to be forced into it if it's a multi-line symbol
+// or if the quoting would get super complicated.
+function shouldPrintPercentSDynaSymbol(node) {
+  // We shouldn't print a %s dyna symbol if it was not already that way in the
+  // original source.
+  if (node.quote[0] !== "%") {
+    return false;
+  }
+
+  // Here we're going to check if there is a closing character, a new line, or a
+  // quote in the content of the dyna symbol. If there is, then quoting could
+  // get weird, so just bail out and stick to the original bounds in the source.
+  const closing = quotePairs[node.quote[2]];
+
+  return node.body.some(
+    (child) =>
+      child.type === "@tstring_content" &&
+      (child.body.includes("\n") ||
+        child.body.includes(closing) ||
+        child.body.includes("'") ||
+        child.body.includes('"'))
+  );
+}
+
 // Prints a dynamic symbol. Assumes there's a quote property attached to the
 // node that will tell us which quote to use when printing. We're just going to
 // use whatever quote was provided.
+//
+// In the case of a plain dyna symbol, node.quote will be either :" or :'
+// For %s dyna symbols, node.quote will be %s[, %s(, %s{, or %s<
 function printDynaSymbol(path, opts, print) {
-  const { quote } = path.getValue();
+  const node = path.getValue();
+
+  if (shouldPrintPercentSDynaSymbol(node)) {
+    return printPercentSDynaSymbol(path, opts, print);
+  }
+
+  const parts = [];
+  let quote;
+
+  if (isQuoteLocked(node)) {
+    if (node.quote.startsWith("%")) {
+      quote = opts.rubySingleQuote ? "'" : '"';
+    } else {
+      quote = node.quote.slice(1);
+    }
+  } else {
+    quote = opts.rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
+  }
+
+  parts.push(quote);
+  path.each((childPath) => {
+    const child = childPath.getValue();
+
+    if (child.type !== "@tstring_content") {
+      parts.push(print(childPath));
+    } else {
+      parts.push(
+        join(literalline, normalizeQuotes(child.body, quote).split("\n"))
+      );
+    }
+  }, "body");
+
+  parts.push(quote);
+
+  // If we're inside of an assoc_new node as the key, then it will handle
+  // printing the : on its own since it could change sides.
+  const parentNode = path.getParentNode();
+  if (parentNode.type !== "assoc_new" || parentNode.body[0] !== node) {
+    parts.unshift(":");
+  }
 
-  return concat([":", quote].concat(path.map(print, "body")).concat(quote));
+  return concat(parts);
 }
 
 function printStringConcat(path, opts, print) {

data/src/ruby/parser.js

@@ -4,16 +4,14 @@ 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)/;
-
 // This function handles checking whether or not the source string has the
 // pragma for prettier. This is an optional workflow for incremental adoption.
 function hasPragma(text) {
-  return pragmaPattern.test(text);
+  return /^\s*#[^\S\n]*@(format|prettier)\s*(\n|$)/.test(text);
 }
 
 // This function is critical for comments and cursor support, and is responsible

data/src/ruby/parser.rb

@@ -13,8 +13,7 @@ if (RUBY_MAJOR < 2) || ((RUBY_MAJOR == 2) && (RUBY_MINOR < 5))
   exit 1
 end
 
-require 'delegate'
-require 'json'
+require 'json' unless defined?(JSON)
 require 'ripper'
 
 module Prettier
@@ -54,6 +53,35 @@ class Prettier::Parser < Ripper
     end
   end
 
+  # This is a small wrapper around the value of a node for those specific events
+  # that need extra handling. (For example: statement, body statement, and
+  # rescue nodes which all need extra information to determine their character
+  # boundaries.)
+  class Node
+    attr_reader :parser, :value
+
+    def initialize(parser, value)
+      @parser = parser
+      @value = value
+    end
+
+    def [](key)
+      value[key]
+    end
+
+    def dig(*keys)
+      value.dig(*keys)
+    end
+
+    def to_json(*opts)
+      value.to_json(*opts)
+    end
+
+    def pretty_print(q)
+      q.pp_hash(self)
+    end
+  end
+
   attr_reader :source, :lines, :scanner_events
 
   # This is an attr_accessor so Stmts objects can grab comments out of this
@@ -565,6 +593,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],
@@ -611,19 +645,19 @@ class Prettier::Parser < Ripper
   # bodystmt can't actually determine its bounds appropriately because it
   # doesn't necessarily know where it started. So the parent node needs to
   # report back down into this one where it goes.
-  class BodyStmt < SimpleDelegator
+  class BodyStmt < Node
     def bind(sc, ec)
-      merge!(sc: sc, ec: ec)
-      parts = self[:body]
+      value.merge!(sc: sc, ec: ec)
+      parts = value[:body]
 
       # Here we're going to determine the bounds for the stmts
       consequent = parts[1..-1].compact.first
-      self[:body][0].bind(sc, consequent ? consequent[:sc] : ec)
+      value[:body][0].bind(sc, consequent ? consequent[:sc] : ec)
 
       # 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_end(consequent ? consequent[:sc] : ec)
+        value[:body][1].bind_end(consequent ? consequent[:sc] : ec)
       end
     end
   end
@@ -632,6 +666,7 @@ class Prettier::Parser < Ripper
   # of clauses within the body of a method or block.
   def on_bodystmt(stmts, rescued, ensured, elsed)
     BodyStmt.new(
+      self,
       type: :bodystmt,
       body: [stmts, rescued, ensured, elsed],
       sl: lineno,
@@ -656,7 +691,7 @@ class Prettier::Parser < Ripper
       body: [block_var, stmts],
       sl: beging[:sl],
       sc: beging[:sc],
-      el: ending[:el],
+      el: [ending[:el], stmts[:el]].max,
       ec: ending[:ec]
     }
   end
@@ -709,7 +744,7 @@ class Prettier::Parser < Ripper
       body: [receiver, oper, sending],
       sl: receiver[:sl],
       sc: receiver[:sc],
-      el: ending[:el],
+      el: [ending[:el], receiver[:el]].max,
       ec: ending[:ec]
     }
   end
@@ -1057,7 +1092,7 @@ class Prettier::Parser < Ripper
 
       beging.merge(
         type: :dyna_symbol,
-        quote: beging[:body][1],
+        quote: beging[:body],
         body: string[:body],
         el: ending[:el],
         ec: ending[:ec]
@@ -1723,6 +1758,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
@@ -1817,12 +1874,12 @@ class Prettier::Parser < Ripper
   # doesn't really have all of the information that it needs in order to
   # determine its ending. Therefore it relies on its parent bodystmt node to
   # report its ending to it.
-  class Rescue < SimpleDelegator
+  class Rescue < Node
     def bind_end(ec)
-      merge!(ec: ec)
+      value.merge!(ec: ec)
 
-      stmts = self[:body][1]
-      consequent = self[:body][2]
+      stmts = value[:body][1]
+      consequent = value[:body][2]
 
       if consequent
         consequent.bind_end(ec)
@@ -1858,6 +1915,7 @@ class Prettier::Parser < Ripper
       end
 
     Rescue.new(
+      self,
       beging.merge!(
         type: :rescue,
         body: [rescue_ex, stmts, consequent],
@@ -1958,36 +2016,29 @@ class Prettier::Parser < Ripper
   # stmts nodes will report back down the location information. We then
   # propagate that onto void_stmt nodes inside the stmts in order to make sure
   # all comments get printed appropriately.
-  class Stmts < SimpleDelegator
-    attr_reader :parser
-
-    def initialize(parser, values)
-      @parser = parser
-      __setobj__(values)
-    end
-
+  class Stmts < Node
     def bind(sc, ec)
-      merge!(sc: sc, ec: ec)
+      value.merge!(sc: sc, ec: ec)
 
-      if self[:body][0][:type] == :void_stmt
-        self[:body][0].merge!(sc: sc, ec: sc)
+      if value[:body][0][:type] == :void_stmt
+        value[:body][0].merge!(sc: sc, ec: sc)
       end
 
       attach_comments(sc, ec)
     end
 
     def bind_end(ec)
-      merge!(ec: ec)
+      value.merge!(ec: ec)
     end
 
     def <<(statement)
-      if self[:body].any?
-        merge!(statement.slice(:el, :ec))
+      if value[:body].any?
+        value.merge!(statement.slice(:el, :ec))
       else
-        merge!(statement.slice(:sl, :el, :sc, :ec))
+        value.merge!(statement.slice(:sl, :el, :sc, :ec))
       end
 
-      self[:body] << statement
+      value[:body] << statement
       self
     end
 
@@ -2004,7 +2055,7 @@ class Prettier::Parser < Ripper
       return if attachable.empty?
 
       parser.comments -= attachable
-      self[:body] = (self[:body] + attachable).sort_by! { |node| node[:sc] }
+      value[:body] = (value[:body] + attachable).sort_by! { |node| node[:sc] }
     end
   end