rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -4,7 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for checking multiline method calls and binary
     # operations.
-    module MultilineExpressionIndentation
+    module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
+      KEYWORD_ANCESTOR_TYPES  = [:for, :return, *Util::MODIFIER_NODES].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return
+                                   array kwbegin].freeze
+      ASSIGNMENT_RHS_TYPES    = [:send, *Util::ASGN_NODES].freeze
+      DEFAULT_MESSAGE_TAIL    = 'an expression'.freeze
+      ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'.freeze
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` ' \
+                                'statement'.freeze
+
       def on_send(node)
         return if !node.receiver || node.method?(:[])
         return unless relevant_node?(node)
@@ -64,7 +73,7 @@ module RuboCop
       end
 
       def incorrect_style_detected(range, node, lhs, rhs)
-        add_offense(range, range, message(node, lhs, rhs)) do
+        add_offense(range, location: range, message: message(node, lhs, rhs)) do
           if supported_styles.size > 2 ||
              offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected
@@ -79,30 +88,49 @@ module RuboCop
       end
 
       def operation_description(node, rhs)
-        ancestor = kw_node_with_special_indentation(node)
-        if ancestor
-          kw = ancestor.loc.keyword.source
-          kind = kw == 'for' ? 'collection' : 'condition'
-          article = kw =~ /^[iu]/ ? 'an' : 'a'
-          "a #{kind} in #{article} `#{kw}` statement"
-        else
-          'an expression' +
-            (part_of_assignment_rhs(node, rhs) ? ' in an assignment' : '')
+        kw_node_with_special_indentation(node) do |ancestor|
+          return keyword_message_tail(ancestor)
+        end
+
+        part_of_assignment_rhs(node, rhs) do |_node|
+          return ASSIGNMENT_MESSAGE_TAIL
         end
+
+        DEFAULT_MESSAGE_TAIL
       end
 
-      def kw_node_with_special_indentation(node)
-        node.each_ancestor.find do |a|
-          next unless a.loc.respond_to?(:keyword)
+      def keyword_message_tail(node)
+        keyword = node.loc.keyword.source
+        kind    = keyword == 'for' ? 'collection' : 'condition'
+        article = keyword =~ /^[iu]/ ? 'an' : 'a'
 
-          case a.type
-          when :for                  then _, expression, = *a
-          when :return               then expression, = *a
-          when *Util::MODIFIER_NODES then expression, = *a
+        format(KEYWORD_MESSAGE_TAIL, kind: kind,
+                                     article: article,
+                                     keyword: keyword)
+      end
+
+      def kw_node_with_special_indentation(node)
+        keyword_node =
+          node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            next if ancestor.if_type? && ancestor.ternary?
+            within_node?(node, indented_keyword_expression(ancestor))
           end
 
-          within_node?(node, expression) if expression
+        if keyword_node && block_given?
+          yield keyword_node
+        else
+          keyword_node
+        end
+      end
+
+      def indented_keyword_expression(node)
+        if node.for_type?
+          expression = node.collection
+        else
+          expression, = *node
         end
+
+        expression
       end
 
       def argument_in_method_call(node, kind)
@@ -122,17 +150,31 @@ module RuboCop
       end
 
       def part_of_assignment_rhs(node, candidate)
-        node.each_ancestor.find do |a|
-          case a.type
-          when :if, :while, :until, :for, :return, :array, :kwbegin
-            break # other kinds of alignment
-          when :block
-            break if part_of_block_body?(candidate, a)
-          when :send
-            valid_method_rhs_candidate?(candidate, a)
-          when *Util::ASGN_NODES
-            valid_rhs_candidate?(candidate, assignment_rhs(a))
-          end
+        rhs_node = node.each_ancestor.find do |ancestor|
+          break if disqualified_rhs?(candidate, ancestor)
+
+          valid_rhs?(candidate, ancestor)
+        end
+
+        if rhs_node && block_given?
+          yield rhs_node
+        else
+          rhs_node
+        end
+      end
+
+      def disqualified_rhs?(candidate, ancestor)
+        UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
+          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+      end
+
+      def valid_rhs?(candidate, ancestor)
+        if ancestor.send_type?
+          valid_method_rhs_candidate?(candidate, ancestor)
+        elsif Util::ASGN_NODES.include?(ancestor.type)
+          valid_rhs_candidate?(candidate, assignment_rhs(ancestor))
+        else
+          false
         end
       end
 
@@ -146,9 +188,8 @@ module RuboCop
         !candidate || within_node?(candidate, node)
       end
 
-      def part_of_block_body?(candidate, node)
-        _method, _args, body = *node
-        body && within_node?(candidate, body)
+      def part_of_block_body?(candidate, block_node)
+        block_node.body && within_node?(candidate, block_node.body)
       end
 
       def assignment_rhs(node)

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -23,9 +23,15 @@ module RuboCop
             corrector.insert_before(node.loc.end, "\n".freeze)
           end
         else
+          # When a comment immediately before the closing brace gets in the way
+          # of an easy correction, the offense is reported but not auto-
+          # corrected. The user must handle the delicate decision of where to
+          # put the comment.
+          return if new_line_needed_before_closing_brace?(node)
+
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.end,
-                                                          :left))
+            corrector.remove(range_with_surrounding_space(range: node.loc.end,
+                                                          side: :left))
 
             corrector.insert_after(last_element_range_with_trailing_comma(node),
                                    node.loc.end.source)
@@ -35,6 +41,18 @@ module RuboCop
 
       private
 
+      # Returns true for the case
+      #   [a,
+      #    b # comment
+      #   ].some_method
+      def new_line_needed_before_closing_brace?(node)
+        return unless node.chained?
+
+        last_element_line =
+          last_element_range_with_trailing_comma(node).last_line
+        processed_source.comments.any? { |c| c.loc.line == last_element_line }
+      end
+
       def check(node)
         case style
         when :symmetrical then check_symmetrical(node)
@@ -46,24 +64,30 @@ module RuboCop
       def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node, :end, self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
       end
 
       def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node, :end, self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
       end
 
       def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, :end, self.class::SAME_LINE_MESSAGE)
+          add_offense(node, location: :end,
+                            message: self.class::SAME_LINE_MESSAGE)
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, :end, self.class::NEW_LINE_MESSAGE)
+          add_offense(node, location: :end,
+                            message: self.class::NEW_LINE_MESSAGE)
         end
       end
 
@@ -89,8 +113,10 @@ module RuboCop
       end
 
       def last_element_trailing_comma_range(node)
-        range = range_with_surrounding_space(children(node).last.source_range,
-                                             :right).end.resize(1)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
         range.source == ',' ? range : nil
       end
 

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -7,6 +7,9 @@ module RuboCop
     module NegativeConditional
       extend NodePattern::Macros
 
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
+            'negative conditions.'.freeze
+
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 
@@ -20,7 +23,7 @@ module RuboCop
         return unless single_negative?(condition)
         return if node.if_type? && node.else?
 
-        add_offense(node, :expression)
+        add_offense(node)
       end
 
       def negative_conditional_corrector(node)

data/lib/rubocop/cop/mixin/ordered_gem_node.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Bundler/OrderedGems and
+    # Gemspec/OrderedDependencies.
+    module OrderedGemNode
+      def autocorrect(node)
+        previous = previous_declaration(node)
+
+        current_range = declaration_with_comment(node)
+        previous_range = declaration_with_comment(previous)
+
+        lambda do |corrector|
+          swap_range(corrector, current_range, previous_range)
+        end
+      end
+
+      private
+
+      def case_insensitive_out_of_order?(string_a, string_b)
+        string_a.downcase < string_b.downcase
+      end
+
+      def consecutive_lines(previous, current)
+        first_line = get_source_range(current).first_line
+        previous.source_range.last_line == first_line - 1
+      end
+
+      def register_offense(previous, current)
+        message = format(
+          self.class::MSG,
+          previous: gem_name(current),
+          current: gem_name(previous)
+        )
+        add_offense(current, message: message)
+      end
+
+      def gem_name(declaration_node)
+        declaration_node.first_argument.str_content
+      end
+
+      def declaration_with_comment(node)
+        buffer = processed_source.buffer
+        begin_pos = get_source_range(node).begin_pos
+        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        end_pos = buffer.line_range(end_line).end_pos
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def swap_range(corrector, range1, range2)
+        src1 = range1.source
+        src2 = range2.source
+        corrector.replace(range1, src2)
+        corrector.replace(range2, src1)
+      end
+
+      def get_source_range(node)
+        unless cop_config['TreatCommentsAsGroupSeparators']
+          first_comment = processed_source.ast_with_comments[node].first
+          return first_comment.loc.expression unless first_comment.nil?
+        end
+        node.source_range
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/parentheses.rb

@@ -15,8 +15,20 @@ module RuboCop
         lambda do |corrector|
           corrector.remove(node.loc.begin)
           corrector.remove(node.loc.end)
+
+          if ternary_condition?(node) && next_char_is_question_mark?(node)
+            corrector.insert_after(node.loc.end, ' ')
+          end
         end
       end
+
+      def ternary_condition?(node)
+        node.parent && node.parent.if_type? && node.parent.ternary?
+      end
+
+      def next_char_is_question_mark?(node)
+        node.loc.last_column == node.parent.loc.question.column
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/parser_diagnostic.rb

@@ -26,7 +26,10 @@ module RuboCop
                       d.message.capitalize
                     end
 
-          add_offense(nil, d.location, message, d.level)
+          add_offense(nil,
+                      location: d.location,
+                      message: message,
+                      severity: d.level)
         end
       end
     end

data/lib/rubocop/cop/mixin/percent_array.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent arrays.
+    module PercentArray
+      private
+
+      # Ruby does not allow percent arrays in an ambiguous block context.
+      #
+      # @example
+      #
+      #   foo %i[bar baz] { qux }
+      def invalid_percent_array_context?(node)
+        parent = node.parent
+
+        parent && parent.send_type? && parent.arguments.include?(node) &&
+          !parent.parenthesized? && parent.block_literal?
+      end
+
+      def allowed_bracket_array?(node)
+        comments_in_array?(node) || below_array_length?(node) ||
+          invalid_percent_array_context?(node)
+      end
+
+      def message(_node)
+        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
+      end
+
+      def comments_in_array?(node)
+        comments = processed_source.comments
+        array_range = node.source_range.to_a
+
+        comments.any? do |comment|
+          !(comment.loc.expression.to_a & array_range).empty?
+        end
+      end
+
+      def check_percent_array(node)
+        array_style_detected(:percent, node.values.size)
+        add_offense(node) if style == :brackets
+      end
+
+      def check_bracketed_array(node)
+        return if allowed_bracket_array?(node)
+
+        array_style_detected(:brackets, node.values.size)
+        add_offense(node) if style == :percent
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/space_after_punctuation.rb

@@ -5,14 +5,19 @@ module RuboCop
     # Common functionality for cops checking for missing space after
     # punctuation.
     module SpaceAfterPunctuation
-      MSG = 'Space missing after %s.'.freeze
+      MSG = 'Space missing after %<token>s.'.freeze
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token|
-          add_offense(token, token.pos, format(MSG, kind(token)))
+          add_offense(token, location: token.pos,
+                             message: format(MSG, token: kind(token)))
         end
       end
 
+      def autocorrect(token)
+        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+      end
+
       def each_missing_space(tokens)
         tokens.each_cons(2) do |t1, t2|
           next unless kind(t1)
@@ -24,12 +29,12 @@ module RuboCop
       end
 
       def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+        t1.line == t2.line && t2.column == t1.column + offset
       end
 
       def space_required_before?(token)
         !(allowed_type?(token) ||
-          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+          (token.right_curly_brace? && space_forbidden_before_rcurly?))
       end
 
       def allowed_type?(token)
@@ -46,10 +51,6 @@ module RuboCop
       def offset
         1
       end
-
-      def autocorrect(token)
-        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
-      end
     end
   end
 end