rubocop 1.9.1 → 1.22.3

data/lib/rubocop/cop/layout/first_method_parameter_line_break.rb

@@ -30,8 +30,7 @@ module RuboCop
         include FirstElementLineBreak
         extend AutoCorrector
 
-        MSG = 'Add a line break before the first parameter of a ' \
-              'multi-line method parameter list.'
+        MSG = 'Add a line break before the first parameter of a multi-line method parameter list.'
 
         def on_def(node)
           check_method_line_break(node, node.arguments)

data/lib/rubocop/cop/layout/first_parameter_indentation.rb

@@ -41,13 +41,14 @@ module RuboCop
       #   second_param)
       #     123
       #   end
-      class FirstParameterIndentation < Cop
+      class FirstParameterIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include MultilineElementIndentation
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
-             'in method args, relative to %<base_description>s.'
+              'in method args, relative to %<base_description>s.'
 
         def on_def(node)
           return if node.arguments.empty?
@@ -57,12 +58,12 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def brace_alignment_style
           :align_parentheses
         end
@@ -73,7 +74,7 @@ module RuboCop
           left_parenthesis = def_node.arguments.loc.begin
           first_elem = def_node.arguments.first
           return unless first_elem
-          return if first_elem.source_range.line == left_parenthesis.line
+          return if same_line?(first_elem, left_parenthesis)
 
           check_first(first_elem, left_parenthesis, nil, 0)
         end

data/lib/rubocop/cop/layout/hash_alignment.rb

@@ -180,12 +180,15 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MESSAGES = { KeyAlignment => 'Align the keys of a hash literal if ' \
-                      'they span more than one line.',
-                     SeparatorAlignment => 'Align the separators of a hash ' \
-                       'literal if they span more than one line.',
-                     TableAlignment => 'Align the keys and values of a hash ' \
-                       'literal if they span more than one line.' }.freeze
+        MESSAGES = {
+          KeyAlignment => 'Align the keys of a hash literal if they span more than one line.',
+          SeparatorAlignment => 'Align the separators of a hash literal if they span more than ' \
+                                'one line.',
+          TableAlignment => 'Align the keys and values of a hash literal if they span more than ' \
+                            'one line.',
+          KeywordSplatAlignment => 'Align keyword splats with the rest of the hash if it spans ' \
+                                   'more than one line.'
+        }.freeze
 
         def on_send(node)
           return if double_splat?(node)
@@ -193,32 +196,39 @@ module RuboCop
 
           last_argument = node.last_argument
 
-          return unless last_argument.hash_type? &&
-                        ignore_hash_argument?(last_argument)
+          return unless last_argument.hash_type? && ignore_hash_argument?(last_argument)
 
           ignore_node(last_argument)
         end
         alias on_super on_send
         alias on_yield on_send
 
-        def on_hash(node) # rubocop:todo Metrics/CyclomaticComplexity
-          return if ignored_node?(node)
-          return if node.pairs.empty? || node.single_line?
+        def on_hash(node)
+          return if autocorrect_incompatible_with_other_cops?(node) || ignored_node?(node) ||
+                    node.pairs.empty? || node.single_line?
 
-          return unless alignment_for_hash_rockets
-                        .any? { |a| a.checkable_layout?(node) } &&
-                        alignment_for_colons
-                        .any? { |a| a.checkable_layout?(node) }
+          proc = ->(a) { a.checkable_layout?(node) }
+          return unless alignment_for_hash_rockets.any?(proc) && alignment_for_colons.any?(proc)
 
           check_pairs(node)
         end
 
-        attr_accessor :offences_by, :column_deltas
+        attr_accessor :offenses_by, :column_deltas
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(node)
+          return false unless enforce_first_argument_with_fixed_indentation? &&
+                              node.pairs.any? &&
+                              node.parent&.call_type?
+
+          parent_loc = node.parent.loc
+          selector = parent_loc.selector || parent_loc.expression
+          same_line?(selector, node.pairs.first)
+        end
+
         def reset!
-          self.offences_by = {}
+          self.offenses_by = {}
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
         end
 
@@ -242,26 +252,33 @@ module RuboCop
             end
           end
 
-          add_offences
+          add_offenses
+        end
+
+        def add_offenses
+          kwsplat_offenses = offenses_by.delete(KeywordSplatAlignment)
+          register_offenses_with_format(kwsplat_offenses, KeywordSplatAlignment)
+
+          format, offenses = offenses_by.min_by { |_, v| v.length }
+          register_offenses_with_format(offenses, format)
         end
 
-        def add_offences
-          format, offences = offences_by.min_by { |_, v| v.length }
-          (offences || []).each do |offence|
-            add_offense(offence, message: MESSAGES[format]) do |corrector|
-              delta = column_deltas[alignment_for(offence).first.class][offence]
+        def register_offenses_with_format(offenses, format)
+          (offenses || []).each do |offense|
+            add_offense(offense, message: MESSAGES[format]) do |corrector|
+              delta = column_deltas[alignment_for(offense).first.class][offense]
 
-              correct_node(corrector, offence, delta) unless delta.nil?
+              correct_node(corrector, offense, delta) unless delta.nil?
             end
           end
         end
 
         def check_delta(delta, node:, alignment:)
-          offences_by[alignment.class] ||= []
+          offenses_by[alignment.class] ||= []
           return if good_alignment? delta
 
           column_deltas[alignment.class][node] = delta
-          offences_by[alignment.class].push(node)
+          offenses_by[alignment.class].push(node)
         end
 
         def ignore_hash_argument?(node)
@@ -274,7 +291,9 @@ module RuboCop
         end
 
         def alignment_for(pair)
-          if pair.hash_rocket?
+          if pair.kwsplat_type?
+            [KeywordSplatAlignment.new]
+          elsif pair.hash_rocket?
             alignment_for_hash_rockets
           else
             alignment_for_colons
@@ -282,13 +301,11 @@ module RuboCop
         end
 
         def alignment_for_hash_rockets
-          @alignment_for_hash_rockets ||=
-            new_alignment('EnforcedHashRocketStyle')
+          @alignment_for_hash_rockets ||= new_alignment('EnforcedHashRocketStyle')
         end
 
         def alignment_for_colons
-          @alignment_for_colons ||=
-            new_alignment('EnforcedColonStyle')
+          @alignment_for_colons ||= new_alignment('EnforcedColonStyle')
         end
 
         def correct_node(corrector, node, delta)
@@ -356,6 +373,16 @@ module RuboCop
         def good_alignment?(column_deltas)
           column_deltas.values.all?(&:zero?)
         end
+
+        def enforce_first_argument_with_fixed_indentation?
+          return false unless argument_alignment_config['Enabled']
+
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def argument_alignment_config
+          config.for_cop('Layout/ArgumentAlignment')
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -55,7 +55,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Put the closing parenthesis for a method call with a ' \
-        'HEREDOC parameter on the same line as the HEREDOC opening.'
+              'HEREDOC parameter on the same line as the HEREDOC opening.'
 
         def self.autocorrect_incompatible_with
           [Style::TrailingCommaInArguments]
@@ -132,9 +132,7 @@ module RuboCop
         end
 
         def extract_heredoc_argument(node)
-          node.arguments.find do |arg_node|
-            extract_heredoc(arg_node)
-          end
+          node.arguments.find { |arg_node| extract_heredoc(arg_node) }
         end
 
         def extract_heredoc(node)
@@ -169,7 +167,7 @@ module RuboCop
 
           end_of_outer_send = outermost_send.loc.end
 
-          end_of_outer_send.line == end_of_last_arg_of_outer_send.line &&
+          same_line?(end_of_outer_send, end_of_last_arg_of_outer_send) &&
             end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
         end
 
@@ -234,12 +232,7 @@ module RuboCop
         def remove_internal_trailing_comma(node, corrector)
           offset = internal_trailing_comma_offset_from_last_arg(node)
           last_arg_end_pos = node.children.last.source_range.end_pos
-          corrector.remove(
-            range_between(
-              last_arg_end_pos,
-              last_arg_end_pos + offset
-            )
-          )
+          corrector.remove(range_between(last_arg_end_pos, last_arg_end_pos + offset))
         end
 
         def internal_trailing_comma?(node)

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -81,10 +81,7 @@ module RuboCop
         end
 
         def width_message(indentation_width)
-          format(
-            WIDTH_MSG,
-            indentation_width: indentation_width
-          )
+          format(WIDTH_MSG, indentation_width: indentation_width)
         end
 
         def line_too_long?(node)
@@ -126,8 +123,7 @@ module RuboCop
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
           correct_indent_level = base_indent_level(node) + indentation_width
-          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/,
-                    ' ' * correct_indent_level)
+          body.gsub(/^[^\S\r\n]{#{body_indent_level}}/, ' ' * correct_indent_level)
         end
 
         def indented_end(node)
@@ -147,13 +143,6 @@ module RuboCop
           indent_level(base_line)
         end
 
-        def indent_level(str)
-          indentations = str.lines
-                            .map { |line| line[/^\s*/] }
-                            .reject { |line| line.end_with?("\n") }
-          indentations.empty? ? 0 : indentations.min_by(&:size).size
-        end
-
         # Returns '~', '-' or nil
         def heredoc_indent_type(node)
           node.source[/^<<([~-])/, 1]

data/lib/rubocop/cop/layout/indentation_consistency.rb

@@ -118,9 +118,10 @@ module RuboCop
       #       def bar
       #       end
       #   end
-      class IndentationConsistency < Cop
+      class IndentationConsistency < Base
         include Alignment
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Inconsistent indentation detected.'
 
@@ -132,12 +133,12 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         # Not all nodes define `bare_access_modifier?` (for example,
         # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first
         # to avoid a NoMethodError.
@@ -161,8 +162,10 @@ module RuboCop
           # to the level of the module (see `AccessModifierIndentation` cop) we
           # return nil so that `check_alignment` will derive the correct
           # indentation from the first child that is not an access modifier.
-          module_indent = display_column(node.parent.source_range)
           access_modifier_indent = display_column(first_child.source_range)
+          return access_modifier_indent unless node.parent
+
+          module_indent = display_column(node.parent.source_range)
           access_modifier_indent if access_modifier_indent > module_indent
         end
 

data/lib/rubocop/cop/layout/indentation_style.rb

@@ -31,60 +31,55 @@ module RuboCop
       #   def foo
       #     bar
       #   end
-      class IndentationStyle < Cop
+      class IndentationStyle < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = '%<type>s detected in indentation.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           str_ranges = string_literal_ranges(processed_source.ast)
 
           processed_source.lines.each.with_index(1) do |line, lineno|
-            match = find_offence(line)
-            next unless match
-
-            range = source_range(processed_source.buffer,
-                                 lineno,
-                                 match.begin(0)...match.end(0))
+            next unless (range = find_offense(line, lineno))
             next if in_string_literal?(str_ranges, range)
 
-            add_offense(range, location: range)
+            add_offense(range) { |corrector| autocorrect(corrector, range) }
           end
         end
 
-        def autocorrect(range)
+        private
+
+        def autocorrect(corrector, range)
           if range.source.include?("\t")
-            autocorrect_lambda_for_tabs(range)
+            autocorrect_lambda_for_tabs(corrector, range)
           else
-            autocorrect_lambda_for_spaces(range)
+            autocorrect_lambda_for_spaces(corrector, range)
           end
         end
 
-        private
+        def find_offense(line, lineno)
+          match = if style == :spaces
+                    line.match(/\A\s*\t+/)
+                  else
+                    line.match(/\A\s* +/)
+                  end
+          return unless match
 
-        def find_offence(line)
-          if style == :spaces
-            line.match(/\A\s*\t+/)
-          else
-            line.match(/\A\s* +/)
-          end
+          source_range(processed_source.buffer, lineno, match.begin(0)...match.end(0))
         end
 
-        def autocorrect_lambda_for_tabs(range)
-          lambda do |corrector|
-            spaces = ' ' * configured_indentation_width
-            corrector.replace(range, range.source.gsub(/\t/, spaces))
-          end
+        def autocorrect_lambda_for_tabs(corrector, range)
+          spaces = ' ' * configured_indentation_width
+          corrector.replace(range, range.source.gsub(/\t/, spaces))
         end
 
-        def autocorrect_lambda_for_spaces(range)
-          lambda do |corrector|
-            corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
-              "\t" * (match.size / configured_indentation_width)
-            end)
-          end
+        def autocorrect_lambda_for_spaces(corrector, range)
+          corrector.replace(range, range.source.gsub(/\A\s+/) do |match|
+            "\t" * (match.size / configured_indentation_width)
+          end)
         end
 
         def in_string_literal?(ranges, tabs_range)

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -42,16 +42,18 @@ module RuboCop
       #     end
       #   end
       #   end
-      class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
+      class IndentationWidth < Base # rubocop:disable Metrics/ClassLength
         include EndKeywordAlignment
         include Alignment
         include CheckAssignment
         include IgnoredPattern
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
               'spaces for%<name>s indentation.'
 
+        # @!method access_modifier?(node)
         def_node_matcher :access_modifier?, <<~PATTERN
           [(send ...) access_modifier?]
         PATTERN
@@ -133,8 +135,15 @@ module RuboCop
             check_indentation(when_node.loc.keyword, when_node.body)
           end
 
-          check_indentation(case_node.when_branches.last.loc.keyword,
-                            case_node.else_branch)
+          check_indentation(case_node.when_branches.last.loc.keyword, case_node.else_branch)
+        end
+
+        def on_case_match(case_match)
+          case_match.each_in_pattern do |in_pattern_node|
+            check_indentation(in_pattern_node.loc.keyword, in_pattern_node.body)
+          end
+
+          check_indentation(case_match.in_pattern_branches.last.loc.keyword, case_match.else_branch)
         end
 
         def on_if(node, base = node)
@@ -144,12 +153,12 @@ module RuboCop
           check_if(node, node.body, node.else_branch, base.loc)
         end
 
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
         def check_members(base, members)
           check_indentation(base, select_check_member(members.first))
 
@@ -279,8 +288,9 @@ module RuboCop
           name = style == 'normal' ? '' : " #{style}"
           message = message(configured_indentation_width, indentation, name)
 
-          add_offense(node, location: offending_range(body_node, indentation),
-                            message: message)
+          add_offense(offending_range(body_node, indentation), message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def message(configured_indentation_width, indentation, name)
@@ -307,12 +317,23 @@ module RuboCop
         def indentation_to_check?(base_loc, body_node)
           return false if skip_check?(base_loc, body_node)
 
-          if %i[rescue ensure].include?(body_node.type)
+          if body_node.rescue_type?
+            check_rescue?(body_node)
+          elsif body_node.ensure_type?
             block_body, = *body_node
-            return unless block_body
+
+            if block_body&.rescue_type?
+              check_rescue?(block_body)
+            else
+              !block_body.nil?
+            end
+          else
+            true
           end
+        end
 
-          true
+        def check_rescue?(rescue_node)
+          rescue_node.body
         end
 
         def skip_check?(base_loc, body_node)
@@ -320,7 +341,7 @@ module RuboCop
           return true unless body_node
 
           # Don't check if expression is on same line as "then" keyword, etc.
-          return true if body_node.loc.line == base_loc.line
+          return true if same_line?(body_node, base_loc)
 
           return true if starts_with_access_modifier?(body_node)
 

data/lib/rubocop/cop/layout/initial_indentation.rb

@@ -41,10 +41,7 @@ module RuboCop
           return unless token
           return if token.column.zero?
 
-          space_range =
-            range_with_surrounding_space(range: token.pos,
-                                         side: :left,
-                                         newlines: false)
+          space_range = range_with_surrounding_space(range: token.pos, side: :left, newlines: false)
           # If the file starts with a byte order mark (BOM), the column can be
           # non-zero, but then we find out here if there's no space to the left
           # of the first token.

data/lib/rubocop/cop/layout/leading_comment_space.rb

@@ -57,7 +57,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
+            next unless /\A#+[^#\s=+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)
@@ -77,7 +77,7 @@ module RuboCop
         end
 
         def allowed_on_first_line?(comment)
-          shebang?(comment) || rackup_config_file? && rackup_options?(comment)
+          shebang?(comment) || (rackup_config_file? && rackup_options?(comment))
         end
 
         def shebang?(comment)