rubocop 0.80.0 → 1.42.0

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

@@ -12,13 +12,11 @@ module RuboCop
 
       def directive_on_source_line?(line_index)
         source_line_number = line_index + processed_source.buffer.first_line
-        comment =
-          processed_source.comments
-                          .detect { |e| e.location.line == source_line_number }
+        comment = processed_source.comment_at_line(source_line_number)
 
         return false unless comment
 
-        comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        !!DirectiveComment.new(comment).match_captures
       end
 
       def allow_uri?
@@ -26,9 +24,7 @@ module RuboCop
       end
 
       def allowed_uri_position?(line, uri_range)
-        uri_range.begin < max_line_length &&
-          (uri_range.end == line_length(line) ||
-           uri_range.end == line_length(line) - 1)
+        uri_range.begin < max_line_length && uri_range.end == line_length(line)
       end
 
       def line_length(line)
@@ -42,8 +38,10 @@ module RuboCop
         begin_position, end_position = last_uri_match.offset(0).map do |pos|
           pos + indentation_difference(line)
         end
-        return nil if begin_position < max_line_length &&
-                      end_position < max_line_length
+
+        end_position = extend_uri_end_position(line, end_position)
+
+        return nil if begin_position < max_line_length && end_position < max_line_length
 
         begin_position...end_position
       end
@@ -59,17 +57,40 @@ module RuboCop
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
-        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+        index =
+          if line.match?(/^[^\t]/)
+            0
+          else
+            line.index(/[^\t]/) || 0
+          end
+
+        index * (tab_indentation_width - 1)
+      end
+
+      def extend_uri_end_position(line, end_position)
+        # Extend the end position YARD comments with linked URLs of the form {<uri> <title>}
+        if line&.match(/{(\s|\S)*}$/)
+          match = line[end_position..line_length(line)]&.match(/(\s|\S)*}/)
+          end_position += match.offset(0).last
+        end
+
+        # Extend the end position until the start of the next word, if any.
+        # This allows for URIs that are wrapped in quotes or parens to be handled properly
+        # while not allowing additional words to be added after the URL.
+        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
+          end_position += match.offset(0).last
+        end
+        end_position
       end
 
       def tab_indentation_width
-        config.for_cop('Layout/Tab')['IndentationWidth']
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
       end
 
       def uri_regexp
         @uri_regexp ||=
-          URI::DEFAULT_PARSER
-          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+          URI::DEFAULT_PARSER.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
       end
 
       def valid_uri?(uri_ish_string)
@@ -80,8 +101,7 @@ module RuboCop
       end
 
       def line_length_without_directive(line)
-        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-        before_comment.rstrip.length
+        DirectiveComment.before_comment(line).rstrip.length
       end
     end
   end

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

@@ -11,15 +11,12 @@ module RuboCop
       # Return a new `Range` covering the first matching group number for each
       # match of `regex` inside `range`
       def each_match_range(range, regex)
-        range.source.scan(regex) do
-          yield match_range(range, Regexp.last_match)
-        end
+        range.source.scan(regex) { yield match_range(range, Regexp.last_match) }
       end
 
       # For a `match` inside `range`, return a new `Range` covering the match
       def match_range(range, match)
-        range_between(range.begin_pos + match.begin(1),
-                      range.begin_pos + match.end(1))
+        range_between(range.begin_pos + match.begin(1), range.begin_pos + match.end(1))
       end
     end
   end

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

@@ -2,29 +2,41 @@
 
 module RuboCop
   module Cop
+    # @api private
+    #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include ConfigurableMax
+      include AllowedMethods
+      include AllowedPattern
+      include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
+      extend ExcludeLimit
+
+      exclude_limit 'Max'
 
       def on_def(node)
+        return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+
         check_complexity(node, node.method_name)
       end
       alias on_defs on_def
 
       def on_block(node)
         define_method?(node) do |name|
+          return if allowed_method?(name) || matches_allowed_pattern?(name)
+
           check_complexity(node, name)
         end
       end
 
+      alias on_numblock on_block
+
       private
 
+      # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        (block
-         (send nil? :define_method ({sym str} $_))
-         args
-         _)
+        ({block numblock}
+         (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 
       def check_complexity(node, method_name)
@@ -32,6 +44,7 @@ module RuboCop
         return unless node.body
 
         max = cop_config['Max']
+        reset_repeated_csend
         complexity, abc_vector = complexity(node.body)
 
         return unless complexity > max
@@ -42,15 +55,19 @@ module RuboCop
                      abc_vector: abc_vector,
                      max: max)
 
-        add_offense(node, message: msg) do
-          self.max = complexity.ceil
-        end
+        add_offense(node, message: msg) { self.max = complexity.ceil }
       end
 
       def complexity(body)
-        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
-          score + complexity_score_for(n)
+        score = 1
+        body.each_node(:lvasgn, *self.class::COUNTED_NODES) do |node|
+          if node.lvasgn_type?
+            reset_on_lvasgn(node)
+          else
+            score += complexity_score_for(node)
+          end
         end
+        score
       end
     end
   end

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

@@ -18,8 +18,7 @@ module RuboCop
             default = default_cop_config['PreferredMethods']
             merged = cop_config['PreferredMethods']
             overrides = merged.values - default.values
-            merged.reject { |key, _| overrides.include?(key) }
-                  .map { |k, v| [k.to_sym, v] }.to_h
+            merged.reject { |key, _| overrides.include?(key) }.transform_keys(&:to_sym)
           end
       end
 

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

@@ -15,7 +15,7 @@ module RuboCop
         node.arguments.each do |arg|
           on_node(type, arg, :send) do |type_node|
             left_brace = type_node.loc.begin
-            if left_brace && left_brace.line == left_parenthesis.line
+            if left_brace && same_line?(left_brace, left_parenthesis)
               yield type_node, left_parenthesis
               ignore_node(type_node)
             end
@@ -25,16 +25,17 @@ module RuboCop
 
       def check_first(first, left_brace, left_parenthesis, offset)
         actual_column = first.source_range.column
-        expected_column = base_column(left_brace, left_parenthesis) +
-                          configured_indentation_width + offset
+
+        indent_base_column, indent_base_type = indent_base(left_brace, first, left_parenthesis)
+        expected_column = indent_base_column + configured_indentation_width + offset
+
         @column_delta = expected_column - actual_column
-        styles =
-          detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        styles = detected_styles(actual_column, offset, left_parenthesis, left_brace)
 
         if @column_delta.zero?
           check_expected_style(styles)
         else
-          incorrect_style_detected(styles, first, left_parenthesis)
+          incorrect_style_detected(styles, first, indent_base_type)
         end
       end
 
@@ -46,14 +47,34 @@ module RuboCop
         end
       end
 
-      def base_column(left_brace, left_parenthesis)
-        if style == brace_alignment_style
-          left_brace.column
-        elsif left_parenthesis && style == :special_inside_parentheses
-          left_parenthesis.column + 1
-        else
-          left_brace.source_line =~ /\S/
+      def indent_base(left_brace, first, left_parenthesis)
+        return [left_brace.column, :left_brace_or_bracket] if style == brace_alignment_style
+
+        pair = hash_pair_where_value_beginning_with(left_brace, first)
+        if pair && key_and_value_begin_on_same_line?(pair) &&
+           right_sibling_begins_on_subsequent_line?(pair)
+          return [pair.loc.column, :parent_hash_key]
         end
+
+        if left_parenthesis && style == :special_inside_parentheses
+          return [left_parenthesis.column + 1, :first_column_after_left_parenthesis]
+        end
+
+        [left_brace.source_line =~ /\S/, :start_of_line]
+      end
+
+      def hash_pair_where_value_beginning_with(left_brace, first)
+        return unless first && first.parent.loc.begin == left_brace
+
+        first.parent&.parent&.pair_type? ? first.parent.parent : nil
+      end
+
+      def key_and_value_begin_on_same_line?(pair)
+        same_line?(pair.key, pair.value)
+      end
+
+      def right_sibling_begins_on_subsequent_line?(pair)
+        pair.right_sibling && (pair.last_line < pair.right_sibling.first_line)
       end
 
       def detected_styles(actual_column, offset, left_parenthesis, left_brace)
@@ -74,10 +95,12 @@ module RuboCop
         styles
       end
 
-      def incorrect_style_detected(styles, first, left_parenthesis)
-        msg = message(base_description(left_parenthesis))
+      def incorrect_style_detected(styles, first, base_column_type)
+        msg = message(base_description(base_column_type))
+
+        add_offense(first, message: msg) do |corrector|
+          autocorrect(corrector, first)
 
-        add_offense(first, message: msg) do
           ambiguous_style_detected(*styles)
         end
       end

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

@@ -10,22 +10,24 @@ module RuboCop
     module MultilineElementLineBreaks
       private
 
-      def check_line_breaks(_node, children)
-        return if all_on_same_line?(children)
+      def check_line_breaks(_node, children, ignore_last: false)
+        return if all_on_same_line?(children, ignore_last: ignore_last)
 
         last_seen_line = -1
         children.each do |child|
           if last_seen_line >= child.first_line
-            add_offense(child)
+            add_offense(child) { |corrector| EmptyLineCorrector.insert_before(corrector, child) }
           else
             last_seen_line = child.last_line
           end
         end
       end
 
-      def all_on_same_line?(nodes)
+      def all_on_same_line?(nodes, ignore_last: false)
         return true if nodes.empty?
 
+        return same_line?(nodes.first, nodes.last) if ignore_last
+
         nodes.first.first_line == nodes.last.last_line
       end
     end

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

@@ -6,12 +6,10 @@ module RuboCop
     # operations.
     module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
       KEYWORD_ANCESTOR_TYPES  = %i[for if while until return].freeze
-      UNALIGNED_RHS_TYPES     = %i[if while until for return
-                                   array kwbegin].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return array kwbegin].freeze
       DEFAULT_MESSAGE_TAIL    = 'an expression'
       ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'
-      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` ' \
-                                'statement'
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` statement'
 
       def on_send(node)
         return if !node.receiver || node.method?(:[])
@@ -31,28 +29,10 @@ module RuboCop
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent&.send_type?
-        lhs
-      end
-
-      def right_hand_side(send_node)
-        if send_node.operator_method? && send_node.arguments?
-          send_node.first_argument.source_range # not used for method calls
-        else
-          regular_method_right_hand_side(send_node)
-        end
-      end
-
-      def regular_method_right_hand_side(send_node)
-        dot = send_node.loc.dot
-        selector = send_node.loc.selector
-        if send_node.dot? && selector && dot.line == selector.line
-          dot.join(selector)
-        elsif selector
-          selector
-        elsif send_node.implicit_call?
-          dot.join(send_node.loc.begin)
+        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+          lhs = lhs.parent
         end
+        lhs
       end
 
       # The correct indentation of `node` is usually `IndentationWidth`, with
@@ -75,8 +55,7 @@ module RuboCop
         kw_node = kw_node_with_special_indentation(node)
         if kw_node && !postfix_conditional?(kw_node)
           # This cop could have its own IndentationWidth configuration
-          configured_indentation_width +
-            @config.for_cop('Layout/IndentationWidth')['Width']
+          configured_indentation_width + @config.for_cop('Layout/IndentationWidth')['Width']
         else
           configured_indentation_width
         end
@@ -91,9 +70,10 @@ module RuboCop
       end
 
       def incorrect_style_detected(range, node, lhs, rhs)
-        add_offense(range, location: range, message: message(node, lhs, rhs)) do
-          if supported_styles.size > 2 ||
-             offending_range(node, lhs, rhs, alternative_style)
+        add_offense(range, message: message(node, lhs, rhs)) do |corrector|
+          autocorrect(corrector, range)
+
+          if supported_styles.size > 2 || offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected
           else
             opposite_style_detected
@@ -110,9 +90,7 @@ module RuboCop
           return keyword_message_tail(ancestor)
         end
 
-        part_of_assignment_rhs(node, rhs) do |_node|
-          return ASSIGNMENT_MESSAGE_TAIL
-        end
+        part_of_assignment_rhs(node, rhs) { |_node| return ASSIGNMENT_MESSAGE_TAIL }
 
         DEFAULT_MESSAGE_TAIL
       end
@@ -122,9 +100,7 @@ module RuboCop
         kind    = keyword == 'for' ? 'collection' : 'condition'
         article = keyword.start_with?('i', 'u') ? 'an' : 'a'
 
-        format(KEYWORD_MESSAGE_TAIL, kind: kind,
-                                     article: article,
-                                     keyword: keyword)
+        format(KEYWORD_MESSAGE_TAIL, kind: kind, article: article, keyword: keyword)
       end
 
       def kw_node_with_special_indentation(node)
@@ -152,7 +128,7 @@ module RuboCop
         expression
       end
 
-      def argument_in_method_call(node, kind)
+      def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
         node.each_ancestor(:send, :block).find do |a|
           # If the node is inside a block, it makes no difference if that block
           # is an argument in a method call. It doesn't count.
@@ -160,11 +136,9 @@ module RuboCop
 
           next if a.setter_method?
           next unless kind == :with_or_without_parentheses ||
-                      kind == :with_parentheses && parentheses?(a)
+                      (kind == :with_parentheses && parentheses?(a))
 
-          a.arguments.any? do |arg|
-            within_node?(node, arg)
-          end
+          a.arguments.any? { |arg| within_node?(node, arg) }
         end
       end
 
@@ -184,7 +158,7 @@ module RuboCop
 
       def disqualified_rhs?(candidate, ancestor)
         UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
-          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+          (ancestor.block_type? && part_of_block_body?(candidate, ancestor))
       end
 
       def valid_rhs?(candidate, ancestor)
@@ -199,8 +173,7 @@ module RuboCop
 
       # The []= operator and setters (a.b = c) are parsed as :send nodes.
       def valid_method_rhs_candidate?(candidate, node)
-        node.setter_method? &&
-          valid_rhs_candidate?(candidate, node.last_argument)
+        node.setter_method? && valid_rhs_candidate?(candidate, node.last_argument)
       end
 
       def valid_rhs_candidate?(candidate, node)
@@ -223,8 +196,7 @@ module RuboCop
 
       def not_for_this_cop?(node)
         node.ancestors.any? do |ancestor|
-          grouped_expression?(ancestor) ||
-            inside_arg_list_parentheses?(node, ancestor)
+          grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
         end
       end
 

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

@@ -24,11 +24,9 @@ module RuboCop
       #    b # comment
       #   ].some_method
       def new_line_needed_before_closing_brace?(node)
-        last_element_line =
-          last_element_range_with_trailing_comma(node).last_line
+        last_element_line = last_element_range_with_trailing_comma(node).last_line
 
-        last_element_commented =
-          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+        last_element_commented = processed_source.comment_at_line(last_element_line)
 
         last_element_commented && (node.chained? || node.argument?)
       end
@@ -44,30 +42,32 @@ module RuboCop
       def check_new_line(node)
         return unless closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_NEW_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_same_line(node)
         return if closing_brace_on_same_line?(node)
 
-        add_offense(node,
-                    location: :end,
-                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
+        add_offense(node.loc.end, message: self.class::ALWAYS_SAME_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
       end
 
       def check_symmetrical(node)
         if opening_brace_on_same_line?(node)
           return if closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::SAME_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::SAME_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         else
           return unless closing_brace_on_same_line?(node)
 
-          add_offense(node, location: :end,
-                            message: self.class::NEW_LINE_MESSAGE)
+          add_offense(node.loc.end, message: self.class::NEW_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
         end
       end
 
@@ -90,7 +90,7 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.first_line
+        same_line?(node.loc.begin, children(node).first)
       end
 
       # This method depends on the fact that we have guarded

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

@@ -7,15 +7,17 @@ module RuboCop
     module NegativeConditional
       extend NodePattern::Macros
 
-      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
-            'negative conditions.'
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for negative conditions.'
 
       private
 
+      # @!method single_negative?(node)
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+
+      # @!method empty_condition?(node)
       def_node_matcher :empty_condition?, '(begin)'
 
-      def check_negative_conditional(node)
+      def check_negative_conditional(node, message:, &block)
         condition = node.condition
 
         return if empty_condition?(condition)
@@ -25,7 +27,7 @@ module RuboCop
         return unless single_negative?(condition)
         return if node.if_type? && node.else?
 
-        add_offense(node)
+        add_offense(node, message: message, &block)
       end
     end
   end

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

@@ -7,19 +7,17 @@ module RuboCop
     # 2. Added to NilClass by explicitly requiring any standard libraries
     # 3. Cop's configuration parameter AllowedMethods.
     module NilMethods
+      include AllowedMethods
+
       private
 
       def nil_methods
-        nil.methods + other_stdlib_methods + allowed_methods
+        nil.methods + other_stdlib_methods + allowed_methods.map(&:to_sym)
       end
 
       def other_stdlib_methods
         [:to_d]
       end
-
-      def allowed_methods
-        cop_config['AllowedMethods'].map(&:to_sym)
-      end
     end
   end
 end

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

@@ -15,15 +15,17 @@ module RuboCop
         node.source_range
       end
 
+      def gem_canonical_name(name)
+        name = name.tr('-_', '') unless cop_config['ConsiderPunctuation']
+        name.downcase
+      end
+
       def case_insensitive_out_of_order?(string_a, string_b)
-        string_a.downcase < string_b.downcase
+        gem_canonical_name(string_a) < gem_canonical_name(string_b)
       end
 
       def consecutive_lines(previous, current)
-        first_line = get_source_range(
-          current,
-          treat_comments_as_separators
-        ).first_line
+        first_line = get_source_range(current, treat_comments_as_separators).first_line
         previous.source_range.last_line == first_line - 1
       end
 
@@ -33,7 +35,15 @@ module RuboCop
           previous: gem_name(current),
           current: gem_name(previous)
         )
-        add_offense(current, message: message)
+
+        add_offense(current, message: message) do |corrector|
+          OrderedGemCorrector.correct(
+            processed_source,
+            current,
+            previous_declaration(current),
+            treat_comments_as_separators
+          ).call(corrector)
+        end
       end
 
       def gem_name(declaration_node)

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

@@ -9,8 +9,7 @@ module RuboCop
       def parens_required?(node)
         range  = node.source_range
         source = range.source_buffer.source
-        source[range.begin_pos - 1] =~ /[a-z]/ ||
-          source[range.end_pos] =~ /[a-z]/
+        /[a-z]/.match?(source[range.begin_pos - 1]) || /[a-z]/.match?(source[range.end_pos])
       end
     end
   end