prettier 0.12.2

data/src/nodes/strings.js

@@ -0,0 +1,143 @@
+const {
+  concat,
+  group,
+  hardline,
+  indent,
+  join,
+  literalline,
+  softline
+} = require("../builders");
+const { concatBody, empty, makeList, surround } = require("../utils");
+const escapePattern = require("../escapePattern");
+
+// If there is some part of this string that matches an escape sequence or that
+// contains the interpolation pattern ("#{"), then we are locked into whichever
+// quote the user chose. (If they chose single quotes, then double quoting
+// would activate the escape sequence, and if they chose double quotes, then
+// single quotes would deactivate it.)
+const isQuoteLocked = string =>
+  string.body.some(
+    part =>
+      part.type === "@tstring_content" &&
+      (escapePattern.test(part.body) || part.body.includes("#{"))
+  );
+
+// A string is considered to be able to use single quotes if it contains only
+// plain string content and that content does not contain a single quote.
+const isSingleQuotable = string =>
+  string.body.every(
+    part => part.type === "@tstring_content" && !part.body.includes("'")
+  );
+
+const getStringQuote = (string, preferSingleQuotes) => {
+  if (isQuoteLocked(string)) {
+    return string.quote;
+  }
+
+  return preferSingleQuotes && isSingleQuotable(string) ? "'" : '"';
+};
+
+const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
+
+const makeString = (content, enclosingQuote) => {
+  const otherQuote = enclosingQuote === '"' ? "'" : enclosingQuote;
+
+  // Escape and unescape single and double quotes as needed to be able to
+  // enclose `content` with `enclosingQuote`.
+  return content.replace(quotePattern, (match, escaped, quote) => {
+    if (escaped === otherQuote) {
+      return escaped;
+    }
+
+    if (quote === enclosingQuote) {
+      return `\\${quote}`;
+    }
+
+    if (quote) {
+      return quote;
+    }
+
+    return `\\${escaped}`;
+  });
+};
+
+module.exports = {
+  "@CHAR": (path, { preferSingleQuotes }, _print) => {
+    const { body } = path.getValue();
+
+    if (body.length !== 2) {
+      return body;
+    }
+
+    const quote = preferSingleQuotes ? "'" : '"';
+    return body.length === 2 ? concat([quote, body.slice(1), quote]) : body;
+  },
+  heredoc: (path, opts, print) => {
+    const { beging, ending } = path.getValue();
+
+    return concat([
+      beging,
+      concat([literalline].concat(path.map(print, "body"))),
+      ending
+    ]);
+  },
+  string: makeList,
+  string_concat: (path, opts, print) =>
+    group(
+      concat([
+        path.call(print, "body", 0),
+        " \\",
+        indent(concat([hardline, path.call(print, "body", 1)]))
+      ])
+    ),
+  string_dvar: surround("#{", "}"),
+  string_embexpr: (path, opts, print) =>
+    group(
+      concat([
+        "#{",
+        indent(concat([softline, path.call(print, "body", 0)])),
+        concat([softline, "}"])
+      ])
+    ),
+  string_literal: (path, { preferSingleQuotes }, print) => {
+    const string = path.getValue().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) {
+      return preferSingleQuotes ? "''" : '""';
+    }
+
+    const quote = getStringQuote(string, preferSingleQuotes);
+    const parts = [];
+
+    string.body.forEach((part, index) => {
+      if (part.type === "@tstring_content") {
+        // In this case, the part of the string is just regular string content
+        parts.push(makeString(part.body, quote));
+      } else {
+        // In this case, the part of the string is an embedded expression
+        parts.push(path.call(print, "body", 0, "body", index));
+      }
+    });
+
+    return concat([quote].concat(parts).concat([quote]));
+  },
+  word_add: concatBody,
+  word_new: empty,
+  xstring: makeList,
+  xstring_literal: (path, opts, print) =>
+    group(
+      concat([
+        "`",
+        indent(concat([softline, join(softline, path.call(print, "body", 0))])),
+        concat([softline, "`"])
+      ])
+    )
+};

data/src/parse.js

@@ -0,0 +1,16 @@
+const { spawnSync } = require("child_process");
+const path = require("path");
+
+module.exports = (text, _parsers, _opts) => {
+  const child = spawnSync("ruby", [path.join(__dirname, "./ripper.rb")], {
+    input: text
+  });
+
+  const error = child.stderr.toString();
+  if (error) {
+    throw new Error(error);
+  }
+
+  const response = child.stdout.toString();
+  return JSON.parse(response);
+};

data/src/print.js

@@ -0,0 +1,23 @@
+const { printComments } = require("./utils");
+const nodes = require("./nodes");
+
+module.exports = (path, opts, print) => {
+  const { type, body, comments, start } = path.getValue();
+
+  if (type in nodes) {
+    const printed = nodes[type](path, opts, print);
+
+    if (comments) {
+      return printComments(printed, start, comments);
+    }
+    return printed;
+  }
+
+  if (type[0] === "@") {
+    return body;
+  }
+
+  throw new Error(
+    `Unsupported node encountered: ${type}\n${JSON.stringify(body, null, 2)}`
+  );
+};

data/src/ripper.rb

@@ -0,0 +1,542 @@
+#!/usr/bin/env ruby
+
+REQUIRED_VERSION = Gem::Version.new('2.5')
+if Gem::Version.new(RUBY_VERSION) < REQUIRED_VERSION
+  raise "Ruby version #{RUBY_VERSION} not supported. " \
+          "Please upgrade to #{REQUIRED_VERSION} or above."
+end
+
+require 'json' unless defined?(JSON)
+require 'ripper'
+
+module Layer
+  # Some nodes are lists that come back from the parser. They always start with
+  # a *_new node (or in the case of string, *_content) and each additional node
+  # in the list is a *_add node. This layer takes those nodes and turns them
+  # into one node with an array body.
+  module Lists
+    events = %i[
+      args
+      mlhs
+      mrhs
+      qsymbols
+      qwords
+      regexp
+      stmts
+      string
+      symbols
+      words
+      xstring
+    ]
+
+    private
+
+    events.each do |event|
+      suffix = event == :string ? 'content' : 'new'
+
+      define_method(:"on_#{event}_#{suffix}") do
+        { type: event, body: [], start: lineno, end: lineno }
+      end
+
+      define_method(:"on_#{event}_add") do |parts, part|
+        parts.tap do |node|
+          node[:body] << part
+          node[:end] = lineno
+        end
+      end
+    end
+  end
+
+  # For most nodes, it's enough to look at the child nodes to determine the
+  # start of the parent node. However, for some nodes it's necessary to keep
+  # track of the keywords as they come in from the lexer and to modify the start
+  # node once we have it.
+  module StartLine
+    events = %i[begin else elsif ensure rescue until while]
+
+    def initialize(*args)
+      super(*args)
+      @keywords = []
+    end
+
+    def self.prepended(base)
+      base.attr_reader :keywords
+    end
+
+    private
+
+    def find_start(body)
+      keywords[keywords.rindex { |keyword| keyword[:body] == body }][:start]
+    end
+
+    events.each do |event|
+      keyword = event.to_s
+
+      define_method(:"on_#{event}") do |*body|
+        super(*body).tap { |sexp| sexp.merge!(start: find_start(keyword)) }
+      end
+    end
+
+    def on_kw(body)
+      super(body).tap { |sexp| keywords << sexp }
+    end
+
+    def on_program(*body)
+      super(*body).tap { |sexp| sexp.merge!(start: 1) }
+    end
+  end
+
+  # Nodes that are always on their own line occur when the lexer is in the
+  # EXPR_BEG node. Those comments are tracked within the @block_comments
+  # instance variable. Then for each node that could contain them, we attach
+  # them after the node has been built.
+  module BlockComments
+    events = {
+      begin: [0, :body, 0],
+      bodystmt: [0],
+      class: [2, :body, 0],
+      def: [2, :body, 0],
+      defs: [4, :body, 0],
+      else: [0],
+      elsif: [1],
+      ensure: [0],
+      if: [1],
+      program: [0],
+      rescue: [2],
+      sclass: [1, :body, 0],
+      unless: [1],
+      until: [1],
+      when: [1],
+      while: [1]
+    }
+
+    def initialize(*args)
+      super(*args)
+      @block_comments = []
+      @current_embdoc = nil
+    end
+
+    def self.prepended(base)
+      base.attr_reader :block_comments, :current_embdoc
+    end
+
+    private
+
+    def attach_comments(sexp, stmts)
+      range = sexp[:start]..sexp[:end]
+      comments =
+        block_comments.group_by { |comment| range.include?(comment[:start]) }
+
+      if comments[true]
+        stmts[:body] =
+          (stmts[:body] + comments[true]).sort_by { |node| node[:start] }
+
+        @block_comments = comments.fetch(false) { [] }
+      end
+    end
+
+    events.each do |event, path|
+      define_method(:"on_#{event}") do |*body|
+        super(*body).tap { |sexp| attach_comments(sexp, body.dig(*path)) }
+      end
+    end
+
+    def on_comment(body)
+      super(body).tap do |sexp|
+        block_comments << sexp if RipperJS.lex_state_name(state) == 'EXPR_BEG'
+      end
+    end
+
+    def on_embdoc_beg(comment)
+      @current_embdoc = {
+        type: :embdoc, body: comment, start: lineno, end: lineno
+      }
+    end
+
+    def on_embdoc(comment)
+      @current_embdoc[:body] << comment
+    end
+
+    def on_embdoc_end(comment)
+      @current_embdoc[:body] << comment.chomp
+      @block_comments << @current_embdoc
+      @current_embdoc = nil
+    end
+
+    def on_method_add_block(*body)
+      super(*body).tap do |sexp|
+        stmts = body[1][:body][1]
+        stmts = stmts[:type] == :stmts ? stmts : body[1][:body][1][:body][0]
+
+        attach_comments(sexp, stmts)
+      end
+    end
+  end
+
+  # Tracking heredocs in somewhat interesting. Straight-line heredocs are
+  # reported as strings, whereas squiggly-line heredocs are reported as
+  # heredocs.
+  module Heredocs
+    def initialize(*args)
+      super(*args)
+      @heredoc_stack = []
+    end
+
+    def self.prepended(base)
+      base.attr_reader :heredoc_stack
+    end
+
+    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
+
+    def on_heredoc_beg(beging)
+      heredoc = { type: :heredoc, beging: beging, start: lineno, end: lineno }
+      heredoc_stack << heredoc
+    end
+
+    def on_heredoc_end(ending)
+      heredoc_stack[-1].merge!(ending: ending.chomp, end: lineno)
+    end
+
+    def on_heredoc_dedent(string, _width)
+      heredoc = heredoc_stack.pop
+      string.merge!(heredoc.slice(:type, :beging, :ending, :start, :end))
+    end
+
+    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))
+      else
+        super
+      end
+    end
+  end
+
+  # These are the event types that contain _actual_ string content. If there is
+  # an encoding magic comment at the top of the file, ripper will actually
+  # change into that encoding for the storage of the string. This will break
+  # everything, so we need to force the encoding back into UTF-8 so that
+  # the JSON library won't break.
+  module Encoding
+    events = %w[comment ident tstring_content]
+
+    events.each do |event|
+      define_method(:"on_#{event}") do |body|
+        super(body.force_encoding('UTF-8'))
+      end
+    end
+  end
+
+  # This layer keeps track of inline comments as they come in. Ripper itself
+  # doesn't attach comments to the AST, so we need to do it manually. In this
+  # case, inline comments are defined as any comments wherein the lexer state is
+  # not equal to EXPR_BEG (tracked in the BlockComments layer).
+  module InlineComments
+    # Certain events needs to steal the comments from their children in order
+    # for them to display properly.
+    events = {
+      args_add_block: [:body, 0],
+      break: [:body, 0],
+      command: [:body, 1],
+      command_call: [:body, 3],
+      regexp_literal: [:body, 0],
+      string_literal: [:body, 0],
+      symbol_literal: [:body, 0]
+    }
+
+    def initialize(*args)
+      super(*args)
+      @inline_comments = []
+      @last_sexp = nil
+    end
+
+    def self.prepended(base)
+      base.attr_reader :inline_comments, :last_sexp
+    end
+
+    private
+
+    events.each do |event, path|
+      define_method(:"on_#{event}") do |*body|
+        @last_sexp =
+          super(*body).tap do |sexp|
+            comments = (sexp.dig(*path) || {}).delete(:comments)
+            sexp.merge!(comments: comments) if comments
+          end
+      end
+    end
+
+    SPECIAL_LITERALS = %i[qsymbols qwords symbols words].freeze
+
+    # Special array literals are handled in different ways and so their comments
+    # need to be passed up to their parent array node.
+    def on_array(*body)
+      @last_sexp =
+        super(*body).tap do |sexp|
+          next unless SPECIAL_LITERALS.include?(body.dig(0, :type))
+
+          comments = sexp.dig(:body, 0).delete(:comments)
+          sexp.merge!(comments: comments) if comments
+        end
+    end
+
+    # Handling this specially because we want to pull the comments out of both
+    # child nodes.
+    def on_assoc_new(*body)
+      @last_sexp =
+        super(*body).tap do |sexp|
+          comments =
+            (sexp.dig(:body, 0).delete(:comments) || []) +
+              (sexp.dig(:body, 1).delete(:comments) || [])
+
+          sexp.merge!(comments: comments) if comments.any?
+        end
+    end
+
+    # Most scanner events don't stand on their own a s-expressions, but the CHAR
+    # scanner event is effectively just a string, so we need to track it as a
+    # s-expression.
+    def on_CHAR(body)
+      @last_sexp = super(body)
+    end
+
+    # We need to know exactly where the comment is, switching off the current
+    # lexer state. In Ruby 2.7.0-dev, that's defined as:
+    #
+    # enum lex_state_bits {
+    #     EXPR_BEG_bit,    /* ignore newline, +/- is a sign. */
+    #     EXPR_END_bit,    /* newline significant, +/- is an operator. */
+    #     EXPR_ENDARG_bit,    /* ditto, and unbound braces. */
+    #     EXPR_ENDFN_bit,    /* ditto, and unbound braces. */
+    #     EXPR_ARG_bit,    /* newline significant, +/- is an operator. */
+    #     EXPR_CMDARG_bit,    /* newline significant, +/- is an operator. */
+    #     EXPR_MID_bit,    /* newline significant, +/- is an operator. */
+    #     EXPR_FNAME_bit,    /* ignore newline, no reserved words. */
+    #     EXPR_DOT_bit,    /* right after `.' or `::', no reserved words. */
+    #     EXPR_CLASS_bit,    /* immediate after `class', no here document. */
+    #     EXPR_LABEL_bit,    /* flag bit, label is allowed. */
+    #     EXPR_LABELED_bit,    /* flag bit, just after a label. */
+    #     EXPR_FITEM_bit,    /* symbol literal as FNAME. */
+    #     EXPR_MAX_STATE
+    # };
+    def on_comment(body)
+      sexp = { type: :@comment, body: body.chomp, start: lineno, end: lineno }
+
+      case RipperJS.lex_state_name(state)
+      when 'EXPR_END', 'EXPR_ARG|EXPR_LABELED', 'EXPR_ENDFN'
+        last_sexp.merge!(comments: [sexp])
+      when 'EXPR_CMDARG', 'EXPR_END|EXPR_ENDARG', 'EXPR_ENDARG', 'EXPR_ARG',
+           'EXPR_FNAME|EXPR_FITEM', 'EXPR_CLASS', 'EXPR_END|EXPR_LABEL'
+        inline_comments << sexp
+      when 'EXPR_BEG|EXPR_LABEL', 'EXPR_MID'
+        inline_comments << sexp.merge!(break: true)
+      when 'EXPR_DOT'
+        last_sexp.merge!(comments: [sexp.merge!(break: true)])
+      end
+
+      sexp
+    end
+
+    defined_events = private_instance_methods(false).grep(/\Aon_/) { $'.to_sym }
+
+    (Ripper::PARSER_EVENTS - defined_events).each do |event|
+      define_method(:"on_#{event}") do |*body|
+        super(*body).tap do |sexp|
+          @last_sexp = sexp
+          next if inline_comments.empty?
+
+          sexp[:comments] = inline_comments.reverse
+          @inline_comments = []
+        end
+      end
+    end
+  end
+
+  # Handles __END__ syntax, which allows individual scripts to keep content
+  # after the main ruby code that can be read through DATA.
+  module Ending
+    def initialize(source, *args)
+      super(source, *args)
+      @source = source
+      @ending = nil
+    end
+
+    def self.prepended(base)
+      base.attr_reader :source, :ending
+    end
+
+    private
+
+    def on___end__(body)
+      @ending = super(source.split("\n")[lineno..-1].join("\n"))
+    end
+
+    def on_program(*body)
+      super(*body).tap { |sexp| sexp[:body][0][:body] << ending if ending }
+    end
+  end
+
+  # Adds the used quote type onto string nodes.
+  module Strings
+    private
+
+    def on_tstring_end(quote)
+      last_sexp.merge!(quote: quote)
+    end
+
+    def on_label_end(quote)
+      last_sexp.merge!(quote: quote[0]) # quote is ": or ':
+    end
+  end
+
+  # Normally access controls are reported as vcall nodes. This module creates a
+  # new node type to explicitly track those nodes instead.
+  module AccessControls
+    def initialize(source, *args)
+      super(source, *args)
+      @lines = source.split("\n")
+    end
+
+    def self.prepended(base)
+      base.attr_reader :lines
+    end
+
+    private
+
+    def on_vcall(ident)
+      super(ident).tap do |sexp|
+        if !%w[private protected public].include?(ident[:body]) ||
+           ident[:body] != lines[lineno - 1].strip
+          next
+        end
+
+        sexp.merge!(type: :access_ctrl)
+      end
+    end
+  end
+end
+
+class RipperJS < Ripper
+  private
+
+  SCANNER_EVENTS.each do |event|
+    define_method(:"on_#{event}") do |body|
+      { type: :"@#{event}", body: body, start: lineno, end: lineno }
+    end
+  end
+
+  PARSER_EVENTS.each do |event|
+    define_method(:"on_#{event}") do |*body|
+      min = body.map { |part| part.is_a?(Hash) ? part[:start] : lineno }.min
+      { type: event, body: body, start: min || lineno, end: lineno }
+    end
+  end
+
+  prepend Layer::Lists
+  prepend Layer::StartLine
+  prepend Layer::InlineComments
+  prepend Layer::BlockComments
+  prepend Layer::Heredocs
+  prepend Layer::Encoding
+  prepend Layer::Ending
+  prepend Layer::Strings
+  prepend Layer::AccessControls
+
+  # When the only statement inside of a `def` node is a `begin` node, then you
+  # can safely replace the body of the `def` with the body of the `begin`. For
+  # example:
+  #
+  # def foo
+  #   begin
+  #     try_something
+  #   rescue SomeError => error
+  #     handle_error(error)
+  #   end
+  # end
+  #
+  # can get transformed into:
+  #
+  # def foo
+  #   try_something
+  # rescue SomeError => error
+  #   handle_error(error)
+  # end
+  #
+  # This module handles this by hoisting up the `bodystmt` node from the inner
+  # `begin` up to the `def`.
+  prepend(
+    Module.new do
+      private
+
+      def on_def(ident, params, bodystmt)
+        def_bodystmt = bodystmt
+        stmts, *other_parts = bodystmt[:body]
+
+        if !other_parts.any? && stmts[:body].length == 1 &&
+           stmts.dig(:body, 0, :type) == :begin
+          def_bodystmt = stmts.dig(:body, 0, :body, 0)
+        end
+
+        super(ident, params, def_bodystmt)
+      end
+    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.
+  prepend(
+    Module.new do
+      private
+
+      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
+    end
+  )
+end
+
+if $0 == __FILE__
+  builder = RipperJS.new($stdin.read)
+  response = builder.parse
+
+  if !response && builder.error?
+    STDERR.puts 'Invalid ruby'
+    exit 1
+  end
+
+  puts JSON.fast_generate(response)
+end