prettier 0.12.3 → 0.13.0

data/node_modules/prettier/third-party.js

@@ -1682,6 +1682,10 @@ var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
 var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
 var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
 
+function _class(obj) {
+  return Object.prototype.toString.call(obj);
+}
+
 function is_EOL(c) {
   return c === 0x0A
   /* LF */
@@ -1985,7 +1989,31 @@ function mergeMappings(state, destination, source, overridableKeys) {
 }
 
 function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
-  var index, quantity;
+  var index, quantity; // The output is a plain object here, so keys can only be strings.
+  // We need to convert keyNode to a string, but doing so can hang the process
+  // (deeply nested arrays that explode exponentially using aliases).
+
+  if (Array.isArray(keyNode)) {
+    keyNode = Array.prototype.slice.call(keyNode);
+
+    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+      if (Array.isArray(keyNode[index])) {
+        throwError(state, 'nested arrays are not supported inside keys');
+      }
+
+      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
+        keyNode[index] = '[object Object]';
+      }
+    }
+  } // Avoid code execution in load() via toString property
+  // (still use its own toString for arrays, timestamps,
+  // and whatever user schema extensions happen to have @@toStringTag)
+
+
+  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
+    keyNode = '[object Object]';
+  }
+
   keyNode = String(keyNode);
 
   if (_result === null) {
@@ -3480,6 +3508,7 @@ function encodeHex(character) {
 function State$1(options) {
   this.schema = options['schema'] || default_full;
   this.indent = Math.max(1, options['indent'] || 2);
+  this.noArrayIndent = options['noArrayIndent'] || false;
   this.skipInvalid = options['skipInvalid'] || false;
   this.flowLevel = common.isNothing(options['flowLevel']) ? -1 : options['flowLevel'];
   this.styleMap = compileStyleMap(this.schema, options['styles'] || null);
@@ -4080,14 +4109,16 @@ function writeNode(state, level, object, block, compact, iskey) {
         }
       }
     } else if (type === '[object Array]') {
+      var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
+
       if (block && state.dump.length !== 0) {
-        writeBlockSequence(state, level, state.dump, compact);
+        writeBlockSequence(state, arrayLevel, state.dump, compact);
 
         if (duplicate) {
           state.dump = '&ref_' + duplicateIndex + state.dump;
         }
       } else {
-        writeFlowSequence(state, level, state.dump);
+        writeFlowSequence(state, arrayLevel, state.dump);
 
         if (duplicate) {
           state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;

data/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "0.12.3",
+  "version": "0.13.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/ruby.js",
   "scripts": {
     "lint": "eslint --cache .",
     "print": "prettier --plugin=.",
-    "rubocop": "run() { prettier --plugin=. $@ | bundle exec rubocop --stdin $1; }; run",
     "test": "jest"
   },
   "repository": {
@@ -24,9 +23,9 @@
   },
   "devDependencies": {
     "all-contributors-cli": "^6.1.2",
-    "eslint": "^5.15.0",
+    "eslint": "^6.0.1",
     "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-config-prettier": "^4.3.0",
+    "eslint-config-prettier": "^6.0.0",
     "eslint-plugin-import": "^2.16.0",
     "jest": "^24.0.0"
   },

data/src/nodes/hashes.js

@@ -78,8 +78,9 @@ module.exports = {
       const isInner = index !== assocNodes.length - 1;
       const valueNode = assocNode.body[1];
 
-      const isStraightHeredoc = valueNode.type === "heredoc";
+      const isStraightHeredoc = valueNode && valueNode.type === "heredoc";
       const isSquigglyHeredoc =
+        valueNode &&
         valueNode.type === "string_literal" &&
         valueNode.body[0].type === "heredoc";
 

data/src/ripper.rb

@@ -10,6 +10,15 @@ require 'json' unless defined?(JSON)
 require 'ripper'
 
 class RipperJS < Ripper
+  attr_reader :lines, :__end__
+
+  def initialize(source, *args)
+    super(source, *args)
+
+    @lines = source.split("\n")
+    @__end__ = nil
+  end
+
   private
 
   # Scanner events occur when the lexer hits a new token, like a keyword or an
@@ -99,44 +108,239 @@ class RipperJS < Ripper
     end
   )
 
+  # For each node, we need to attach where it came from in order to be able to
+  # support placing the cursor correctly before and after formatting.
+  #
   # 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. We need accurate start and end lines so that we can
-  # embed block comments into the right kind of node.
+  # node once we have it.
   prepend(
     Module.new do
-      events = %i[begin else elsif ensure if rescue until while]
+      def initialize(source, *args)
+        super(source, *args)
 
-      def initialize(*args)
-        super(*args)
-        @keywords = []
+        @scanner_events = []
+        @line_counts = [0]
+
+        source.split("\n").each do |line|
+          line_counts << line_counts.last + line.size + 1
+        end
       end
 
       def self.prepended(base)
-        base.attr_reader :keywords
+        base.attr_reader :scanner_events, :line_counts
       end
 
       private
 
-      def find_start(body)
-        keywords[keywords.rindex { |keyword| keyword[:body] == body }][:start]
+      def char_pos
+        line_counts[lineno - 1] + column
       end
 
-      events.each do |event|
-        keyword = event.to_s
+      def char_start_for(body)
+        children = body.length == 1 && body[0].is_a?(Array) ? body[0] : body
+        char_starts =
+          children.map { |part| part[:char_start] if part.is_a?(Hash) }.compact
+
+        char_starts.min || char_pos
+      end
 
+      def find_scanner_event(type, body = :any)
+        index =
+          scanner_events.rindex do |scanner_event|
+            scanner_event[:type] == type &&
+              (body == :any || (scanner_event[:body] == body))
+          end
+
+        scanner_events.delete_at(index)
+      end
+
+      # :backref, :const, :embdoc, :embdoc_beg, :embdoc_end,
+      # :embexpr_beg, :embexpr_end, :embvar, :heredoc_beg, :heredoc_end,
+      # :ident, :lbrace, :lbracket, :lparen, :op, :period, :regexp_beg,
+      # :regexp_end, :rparen, :symbeg, :symbols_beg, :tlambda, :tlambeg,
+      # :tstring_beg, :tstring_content, :tstring_end
+
+      events = {
+        BEGIN: [:@kw, 'BEGIN'],
+        END: [:@kw, 'END'],
+        alias: [:@kw, 'alias'],
+        assoc_splat: [:@op, '**'],
+        arg_paren: :@lparen,
+        args_add_star: [:@op, '*'],
+        begin: [:@kw, 'begin'],
+        blockarg: [:@op, '&'],
+        brace_block: :@lbrace,
+        break: [:@kw, 'break'],
+        case: [:@kw, 'case'],
+        class: [:@kw, 'class'],
+        def: [:@kw, 'def'],
+        defined: [:@kw, 'defined?'],
+        defs: [:@kw, 'def'],
+        do_block: [:@kw, 'do'],
+        else: [:@kw, 'else'],
+        elsif: [:@kw, 'elsif'],
+        ensure: [:@kw, 'ensure'],
+        excessed_comma: :@comma,
+        for: [:@kw, 'for'],
+        hash: :@lbrace,
+        if: [:@kw, 'if'],
+        kwrest_param: [:@op, '**'],
+        lambda: :@tlambda,
+        mlhs_paren: :@lparen,
+        mrhs_add_star: [:@op, '*'],
+        module: [:@kw, 'module'],
+        next: [:@kw, 'next'],
+        paren: :@lparen,
+        qsymbols_new: :@qsymbols_beg,
+        qwords_new: :@qwords_beg,
+        redo: [:@kw, 'redo'],
+        regexp_literal: :@regexp_beg,
+        rescue: [:@kw, 'rescue'],
+        rest_param: [:@op, '*'],
+        retry: [:@kw, 'retry'],
+        return0: [:@kw, 'return'],
+        return: [:@kw, 'return'],
+        sclass: [:@kw, 'class'],
+        string_dvar: :@embvar,
+        string_embexpr: :@embexpr_beg,
+        super: [:@kw, 'super'],
+        symbols_new: :@symbols_beg,
+        top_const_field: [:@op, '::'],
+        top_const_ref: [:@op, '::'],
+        undef: [:@kw, 'undef'],
+        unless: [:@kw, 'unless'],
+        until: [:@kw, 'until'],
+        var_alias: [:@kw, 'alias'],
+        when: [:@kw, 'when'],
+        while: [:@kw, 'while'],
+        words_new: :@words_beg,
+        xstring_literal: :@backtick,
+        yield0: [:@kw, 'yield'],
+        yield: [:@kw, 'yield'],
+        zsuper: [:@kw, 'super']
+      }
+
+      events.each do |event, (type, scanned)|
         define_method(:"on_#{event}") do |*body|
-          super(*body).tap { |sexp| sexp.merge!(start: find_start(keyword)) }
+          node = find_scanner_event(type, scanned || :any)
+
+          super(*body).merge!(
+            start: node[:start],
+            char_start: node[:char_start],
+            char_end: char_pos
+          )
         end
       end
 
-      def on_kw(body)
-        super(body).tap { |sexp| keywords << sexp }
+      # Array nodes can contain a myriad of subnodes because of the special
+      # array literal syntax like %w and %i. As a result, we may be looking for
+      # an left bracket, or we may be just looking at the children.
+      def on_array(*body)
+        if body[0] && %i[args args_add_star].include?(body[0][:type])
+          node = find_scanner_event(:@lbracket)
+
+          super(*body).merge!(
+            start: node[:start],
+            char_start: node[:char_start],
+            char_end: char_pos
+          )
+        else
+          super(*body).merge!(
+            char_start: char_start_for(body), char_end: char_pos
+          )
+        end
+      end
+
+      # Params have a somewhat interesting structure in that they are an array
+      # of arrays where the position in the top-level array indicates the type
+      # of param and the subarray is the list of parameters of that type. We
+      # therefore have to flatten them down to get to the location.
+      def on_params(*body)
+        super(*body).merge!(
+          char_start: char_start_for(body.flatten(1)), char_end: char_pos
+        )
+      end
+
+      # String literals and either contain string parts or a heredoc. If it
+      # contains a heredoc we can just go directly to the child nodes, otherwise
+      # we need to look for a `tstring_beg`.
+      def on_string_literal(*body)
+        if body[0][:type] == :heredoc
+          super(*body).merge!(
+            char_start: char_start_for(body), char_end: char_pos
+          )
+        else
+          node = find_scanner_event(:@tstring_beg)
+
+          super(*body).merge!(
+            start: node[:start],
+            char_start: node[:char_start],
+            char_end: char_pos
+          )
+        end
+      end
+
+      # Technically, the `not` operator is a unary operator but is reported as
+      # a keyword and not an operator. Because of the inconsistency, we have to
+      # manually look for the correct scanner event here.
+      def on_unary(*body)
+        node =
+          if body[0] == :not
+            find_scanner_event(:@kw, 'not')
+          else
+            find_scanner_event(:@op)
+          end
+
+        super(*body).merge!(
+          start: node[:start], char_start: node[:char_start], char_end: char_pos
+        )
+      end
+
+      # Symbols don't necessarily have to have a @symbeg event fired before they
+      # start. For example, you can have symbol literals inside an `alias` node
+      # if you're just using bare words, as in: `alias foo bar`. So this is a
+      # special case in which if there is a `:@symbeg` event we can hook on to
+      # then we use it, otherwise we just look at the beginning of the first
+      # child node.
+      %i[dyna_symbol symbol_literal].each do |event|
+        define_method(:"on_#{event}") do |*body|
+          char_start =
+            if scanner_events.any? { |sevent| sevent[:type] == :@symbeg }
+              find_scanner_event(:@symbeg)[:char_start]
+            else
+              char_start_for(body)
+            end
+
+          super(*body).merge!(char_start: char_start, char_end: char_pos)
+        end
       end
 
       def on_program(*body)
-        super(*body).tap { |sexp| sexp.merge!(start: 1) }
+        super(*body).merge!(start: 1, char_start: 0, char_end: char_pos)
+      end
+
+      defined =
+        private_instance_methods(false).grep(/\Aon_/) { $'.to_sym } +
+          %i[embdoc embdoc_beg embdoc_end heredoc_beg heredoc_end]
+
+      (SCANNER_EVENTS - defined).each do |event|
+        define_method(:"on_#{event}") do |body|
+          super(body).tap do |node|
+            node.merge!(char_start: char_pos, char_end: char_pos + body.size)
+
+            scanner_events << node
+          end
+        end
+      end
+
+      (PARSER_EVENTS - defined).each do |event|
+        define_method(:"on_#{event}") do |*body|
+          super(*body).merge!(
+            char_start: char_start_for(body), char_end: char_pos
+          )
+        end
       end
     end
   )
@@ -153,6 +357,7 @@ class RipperJS < Ripper
         aref: [:body, 1],
         args_add_block: [:body, 0],
         break: [:body, 0],
+        call: [:body, 0],
         command: [:body, 1],
         command_call: [:body, 3],
         regexp_literal: [:body, 0],
@@ -238,15 +443,15 @@ class RipperJS < Ripper
       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'
+        case RipperJS.lex_state_name(state).gsub('EXPR_', '')
+        when 'END', 'ARG|LABELED', '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'
+        when 'CMDARG', 'END|ENDARG', 'ENDARG', 'ARG', 'FNAME|FITEM', 'CLASS',
+             'END|LABEL'
           inline_comments << sexp
-        when 'EXPR_BEG|EXPR_LABEL', 'EXPR_MID'
+        when 'BEG|LABEL', 'MID'
           inline_comments << sexp.merge!(break: true)
-        when 'EXPR_DOT'
+        when 'DOT'
           last_sexp.merge!(comments: [sexp.merge!(break: true)])
         end
 
@@ -255,7 +460,7 @@ class RipperJS < Ripper
 
       defined = private_instance_methods(false).grep(/\Aon_/) { $'.to_sym }
 
-      (Ripper::PARSER_EVENTS - defined).each do |event|
+      (PARSER_EVENTS - defined).each do |event|
         define_method(:"on_#{event}") do |*body|
           super(*body).tap do |sexp|
             @last_sexp = sexp
@@ -327,7 +532,8 @@ class RipperJS < Ripper
 
       def on_comment(body)
         super(body).tap do |sexp|
-          block_comments << sexp if RipperJS.lex_state_name(state) == 'EXPR_BEG'
+          lex_state = RipperJS.lex_state_name(state).gsub('EXPR_', '')
+          block_comments << sexp if lex_state == 'BEG'
         end
       end
 
@@ -410,62 +616,40 @@ class RipperJS < Ripper
     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.
   prepend(
     Module.new do
       private
 
+      # 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.
       %w[comment ident tstring_content].each do |event|
         define_method(:"on_#{event}") do |body|
           super(body.force_encoding('UTF-8'))
         end
       end
-    end
-  )
-
-  # Handles __END__ syntax, which allows individual scripts to keep content
-  # after the main ruby code that can be read through DATA. Which looks like:
-  #
-  # foo.bar
-  #
-  # __END__
-  # some other content that isn't read by ripper normally
-  prepend(
-    Module.new do
-      def initialize(source, *args)
-        super(source, *args)
-        @source = source
-        @ending = nil
-      end
-
-      def self.prepended(base)
-        base.attr_reader :source, :ending
-      end
-
-      private
 
+      # Handles __END__ syntax, which allows individual scripts to keep content
+      # after the main ruby code that can be read through DATA. It looks like:
+      #
+      # foo.bar
+      #
+      # __END__
+      # some other content that isn't normally read by ripper
       def on___end__(body)
-        @ending = super(source.split("\n")[lineno..-1].join("\n"))
+        @__end__ = super(lines[lineno..-1].join("\n"))
       end
 
       def on_program(*body)
-        super(*body).tap { |sexp| sexp[:body][0][:body] << ending if ending }
+        super(*body).tap { |node| node[:body][0][:body] << __end__ if __end__ }
       end
-    end
-  )
-
-  # Adds the used quote type onto string nodes. This is necessary because we're
-  # going to have to stick to whatever quote the user chose if there are escape
-  # sequences within the string. For example, if you have '\n' we can't switch
-  # to double quotes without changing what it means.
-  prepend(
-    Module.new do
-      private
 
+      # Adds the used quote type onto string nodes. This is necessary because
+      # we're going to have to stick to whatever quote the user chose if there
+      # are escape sequences within the string. For example, if you have '\n'
+      # we can't switch to double quotes without changing what it means.
       def on_tstring_end(quote)
         last_sexp.merge!(quote: quote)
       end
@@ -473,66 +657,45 @@ class RipperJS < Ripper
       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, so that the printer
-  # can add new lines as necessary.
-  prepend(
-    Module.new do
-      KEYWORDS = %w[private protected public].freeze
-
-      def initialize(source, *args)
-        super(source, *args)
-        @lines = source.split("\n")
-      end
-
-      def self.prepended(base)
-        base.attr_reader :lines
-      end
-
-      private
 
+      # Normally access controls are reported as vcall nodes. This creates a
+      # new node type to explicitly track those nodes instead, so that the
+      # printer can add new lines as necessary.
       def on_vcall(ident)
-        super(ident).tap do |sexp|
-          if !KEYWORDS.include?(ident[:body]) ||
+        @access_controls ||= %w[private protected public].freeze
+
+        super(ident).tap do |node|
+          if !@access_controls.include?(ident[:body]) ||
              ident[:body] != lines[lineno - 1].strip
             next
           end
 
-          sexp.merge!(type: :access_ctrl)
+          node.merge!(type: :access_ctrl)
         end
       end
-    end
-  )
-
-  # 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
 
+      # 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`.
       def on_def(ident, params, bodystmt)
         def_bodystmt = bodystmt
         stmts, *other_parts = bodystmt[:body]
@@ -544,17 +707,11 @@ class RipperJS < Ripper
 
         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
 
+      # 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