prettier 1.2.5 → 1.5.2

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/loops.js

@@ -10,7 +10,7 @@ const {
   softline
 } = require("../../prettier");
 
-const { containsAssignment } = require("../../utils");
+const { containsAssignment, isEmptyStmts } = require("../../utils");
 const inlineEnsureParens = require("../../utils/inlineEnsureParens");
 
 function printLoop(keyword, modifier) {
@@ -19,17 +19,11 @@ function printLoop(keyword, modifier) {
 
     // If the only statement inside this while loop is a void statement, then we
     // can shorten to just displaying the predicate and then a semicolon.
-    if (
-      stmts.body.length === 1 &&
-      stmts.body[0].type === "void_stmt" &&
-      !stmts.body[0].comments
-    ) {
+    if (isEmptyStmts(stmts)) {
       return group(
         concat([
-          keyword,
-          " ",
-          path.call(print, "body", 0),
-          ifBreak(softline, "; "),
+          group(concat([keyword, " ", path.call(print, "body", 0)])),
+          hardline,
           "end"
         ])
       );

data/src/ruby/nodes/methods.js

@@ -1,8 +1,9 @@
 const { concat, group, hardline, indent, line } = require("../../prettier");
+const { isEmptyBodyStmt } = require("../../utils");
 
 function printMethod(offset) {
   return function printMethodWithOffset(path, opts, print) {
-    const [_name, params, body] = path.getValue().body.slice(offset);
+    const [_name, params, bodystmt] = path.getValue().body.slice(offset);
     const declaration = ["def "];
 
     // In this case, we're printing a method that's defined as a singleton, so
@@ -24,16 +25,8 @@ function printMethod(offset) {
       parens ? ")" : ""
     );
 
-    // 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
-    ) {
-      return group(concat(declaration.concat(["; end"])));
+    if (isEmptyBodyStmt(bodystmt)) {
+      return group(concat(declaration.concat("; end")));
     }
 
     return group(

data/src/ruby/nodes/rescue.js

@@ -26,28 +26,10 @@ function printEnsure(path, opts, print) {
 }
 
 function printRescue(path, opts, print) {
-  const [exception, variable, _stmts, addition] = path.getValue().body;
   const parts = ["rescue"];
 
-  if (exception || variable) {
-    if (exception) {
-      if (Array.isArray(exception)) {
-        // In this case, it's actually only the one exception (it's an array
-        // of length 1).
-        parts.push(" ", path.call(print, "body", 0, 0));
-      } else {
-        // Here we have multiple exceptions from which we're rescuing, so we
-        // need to align them and join them together.
-        const joiner = concat([",", line]);
-        const exceptions = group(join(joiner, path.call(print, "body", 0)));
-
-        parts.push(" ", align("rescue ".length, exceptions));
-      }
-    }
-
-    if (variable) {
-      parts.push(" => ", path.call(print, "body", 1));
-    }
+  if (path.getValue().body[0]) {
+    parts.push(align("rescue ".length, path.call(print, "body", 0)));
   } else {
     // If you don't specify an error to rescue in a `begin/rescue` block, then
     // implicitly you're rescuing from `StandardError`. In this case, we're
@@ -55,16 +37,40 @@ function printRescue(path, opts, print) {
     parts.push(" StandardError");
   }
 
-  const rescueBody = path.call(print, "body", 2);
+  const bodystmt = path.call(print, "body", 1);
 
-  if (rescueBody.parts.length > 0) {
-    parts.push(indent(concat([hardline, rescueBody])));
+  if (bodystmt.parts.length > 0) {
+    parts.push(indent(concat([hardline, bodystmt])));
   }
 
   // This is the next clause on the `begin` statement, either another
   // `rescue`, and `ensure`, or an `else` clause.
-  if (addition) {
-    parts.push(concat([hardline, path.call(print, "body", 3)]));
+  if (path.getValue().body[2]) {
+    parts.push(concat([hardline, path.call(print, "body", 2)]));
+  }
+
+  return group(concat(parts));
+}
+
+// This is a container node that we're adding into the AST that isn't present in
+// Ripper solely so that we have a nice place to attach inline comments.
+function printRescueEx(path, opts, print) {
+  const [exception, variable] = path.getValue().body;
+  const parts = [];
+
+  if (exception) {
+    let exceptionDoc = path.call(print, "body", 0);
+
+    if (Array.isArray(exceptionDoc)) {
+      const joiner = concat([",", line]);
+      exceptionDoc = group(join(joiner, exceptionDoc));
+    }
+
+    parts.push(" ", exceptionDoc);
+  }
+
+  if (variable) {
+    parts.push(" => ", path.call(print, "body", 1));
   }
 
   return group(concat(parts));
@@ -89,6 +95,7 @@ module.exports = {
   ensure: printEnsure,
   redo: literal("redo"),
   rescue: printRescue,
+  rescue_ex: printRescueEx,
   rescue_mod: printRescueMod,
   retry: literal("retry")
 };

data/src/ruby/nodes/statements.js

@@ -12,15 +12,13 @@ const {
   trim
 } = require("../../prettier");
 
+const { isEmptyStmts } = require("../../utils");
+
 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
-  ) {
+  if (!isEmptyStmts(stmts)) {
     parts.push(path.call(print, "body", 0));
   }
 
@@ -79,6 +77,9 @@ module.exports = {
     const { body } = path.getValue();
     return concat([trim, "__END__", literalline, body]);
   },
+  "@comment"(path, opts, _print) {
+    return opts.printer.printComment(path);
+  },
   bodystmt: printBodyStmt,
   paren: printParen,
   program: (path, opts, print) =>

data/src/ruby/nodes/strings.js

@@ -4,6 +4,7 @@ const {
   hardline,
   indent,
   literalline,
+  removeLines,
   softline,
   join
 } = require("../../prettier");
@@ -103,14 +104,14 @@ function printStringDVar(path, opts, print) {
 }
 
 function printStringEmbExpr(path, opts, print) {
+  const node = path.getValue();
   const parts = path.call(print, "body", 0);
 
-  // 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, "}"]);
+  // If the contents of this embedded expression were originally on the same
+  // line in the source, then we're going to leave them in place and assume
+  // that's the way the developer wanted this expression represented.
+  if (node.sl === node.el) {
+    return concat(["#{", removeLines(parts), "}"]);
   }
 
   return group(

data/src/ruby/parser.js

@@ -1,59 +1,11 @@
-const { spawnSync } = require("child_process");
-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.
-/* istanbul ignore next */
-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];
-})();
+const parseSync = require("../parser/parseSync");
 
 // 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
 // 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) {
-  const child = spawnSync(
-    "ruby",
-    ["--disable-gems", path.join(__dirname, "./parser.rb")],
-    {
-      env: Object.assign({}, process.env, { LANG }),
-      input: text,
-      maxBuffer: 15 * 1024 * 1024 // 15MB
-    }
-  );
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("ruby", text);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/ruby/parser.rb

@@ -14,13 +14,51 @@ if (RUBY_MAJOR < 2) || ((RUBY_MAJOR == 2) && (RUBY_MINOR < 5))
 end
 
 require 'delegate'
-require 'json' unless defined?(JSON)
+require 'json'
 require 'ripper'
 
-module Prettier; end
+module Prettier
+end
 
 class Prettier::Parser < Ripper
-  attr_reader :source, :lines, :scanner_events, :line_counts
+  # Represents a line in the source. If this class is being used, it means that
+  # every character in the string is 1 byte in length, so we can just return the
+  # start of the line + the index.
+  class SingleByteString
+    def initialize(start)
+      @start = start
+    end
+
+    def [](byteindex)
+      @start + byteindex
+    end
+  end
+
+  # Represents a line in the source. If this class is being used, it means that
+  # there are characters in the string that are multi-byte, so we will build up
+  # an array of indices, such that array[byteindex] will be equal to the index
+  # of the character within the string.
+  class MultiByteString
+    def initialize(start, line)
+      @indices = []
+
+      line
+        .each_char
+        .with_index(start) do |char, index|
+          char.bytesize.times { @indices << index }
+        end
+    end
+
+    def [](byteindex)
+      @indices[byteindex]
+    end
+  end
+
+  attr_reader :source, :lines, :scanner_events
+
+  # This is an attr_accessor so Stmts objects can grab comments out of this
+  # array and attach them to themselves.
+  attr_accessor :comments
 
   def initialize(source, *args)
     super(source, *args)
@@ -35,9 +73,30 @@ class Prettier::Parser < Ripper
     @heredocs = []
 
     @scanner_events = []
-    @line_counts = [0]
+    @line_counts = []
+
+    # Here we're going to build up a list of SingleByteString or MultiByteString
+    # objects. They're each going to represent a string in the source. They are
+    # used by the `char_pos` method to determine where we are in the source
+    # string.
+    last_index = 0
+
+    @source.lines.each do |line|
+      if line.size == line.bytesize
+        @line_counts << SingleByteString.new(last_index)
+      else
+        @line_counts << MultiByteString.new(last_index, line)
+      end
 
-    @source.lines.each { |line| @line_counts << @line_counts.last + line.size }
+      last_index += line.size
+    end
+  end
+
+  def self.parse(source)
+    builder = new(source)
+
+    response = builder.parse
+    response unless builder.error?
   end
 
   private
@@ -48,7 +107,7 @@ class Prettier::Parser < Ripper
   # this line, then we add the number of columns into this line that we've gone
   # through.
   def char_pos
-    line_counts[lineno - 1] + column
+    @line_counts[lineno - 1][column]
   end
 
   # As we build up a list of scanner events, we'll periodically need to go
@@ -118,6 +177,7 @@ class Prettier::Parser < Ripper
     @comments << {
       type: :@comment,
       value: value[1..-1].chomp.force_encoding('UTF-8'),
+      inline: value.strip != lines[lineno - 1],
       sl: lineno,
       el: lineno,
       sc: char_pos,
@@ -505,6 +565,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],
@@ -1761,8 +1827,8 @@ class Prettier::Parser < Ripper
     def bind_end(ec)
       merge!(ec: ec)
 
-      stmts = self[:body][2]
-      consequent = self[:body][3]
+      stmts = self[:body][1]
+      consequent = self[:body][2]
 
       if consequent
         consequent.bind_end(ec)
@@ -1777,16 +1843,30 @@ class Prettier::Parser < Ripper
   # inside of a bodystmt.
   def on_rescue(exceptions, variable, stmts, consequent)
     beging = find_scanner_event(:@kw, 'rescue')
+    exceptions = exceptions[0] if exceptions.is_a?(Array)
 
-    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
-    last_node = variable || last_exception || beging
-
+    last_node = variable || exceptions || beging
     stmts.bind(find_next_statement_start(last_node[:ec]), char_pos)
 
+    # We add an additional inner node here that ripper doesn't provide so that
+    # we have a nice place to attach inline comment. But we only need it if we
+    # have an exception or a variable that we're rescuing.
+    rescue_ex =
+      if exceptions || variable
+        {
+          type: :rescue_ex,
+          body: [exceptions, variable],
+          sl: beging[:sl],
+          sc: beging[:ec] + 1,
+          el: last_node[:el],
+          ec: last_node[:ec]
+        }
+      end
+
     Rescue.new(
       beging.merge!(
         type: :rescue,
-        body: [exceptions, variable, stmts, consequent],
+        body: [rescue_ex, stmts, consequent],
         el: lineno,
         ec: char_pos
       )
@@ -1885,12 +1965,21 @@ class Prettier::Parser < Ripper
   # 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
+
     def bind(sc, ec)
       merge!(sc: sc, ec: ec)
 
       if self[:body][0][:type] == :void_stmt
         self[:body][0].merge!(sc: sc, ec: sc)
       end
+
+      attach_comments(sc, ec)
     end
 
     def bind_end(ec)
@@ -1907,6 +1996,22 @@ class Prettier::Parser < Ripper
       self[:body] << statement
       self
     end
+
+    private
+
+    def attach_comments(sc, ec)
+      attachable =
+        parser.comments.select do |comment|
+          comment[:type] == :@comment && !comment[:inline] &&
+            sc <= comment[:sc] && ec >= comment[:ec] &&
+            !comment[:value].include?('prettier-ignore')
+        end
+
+      return if attachable.empty?
+
+      parser.comments -= attachable
+      self[:body] = (self[:body] + attachable).sort_by! { |node| node[:sc] }
+    end
   end
 
   # stmts_new is a parser event that represents the beginning of a list of
@@ -1914,6 +2019,7 @@ class Prettier::Parser < Ripper
   # stmts_add events, which we'll append onto an array body.
   def on_stmts_new
     Stmts.new(
+      self,
       type: :stmts,
       body: [],
       sl: lineno,
@@ -2542,24 +2648,3 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'super').merge!(type: :zsuper)
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the parser.js spawn. In that case, read the ruby source from
-# stdin and report back the AST over stdout.
-
-if $0 == __FILE__
-  builder = Prettier::Parser.new($stdin.read)
-  response = builder.parse
-
-  if !response || builder.error?
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the ruby source. This usually means there was a syntax error in the ' \
-        'file in question. You can verify by running `ruby -i [path/to/file]`.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end