rubocop 1.10.0 → 1.14.0

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_offence(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_offence(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,7 @@ 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_if(node, base = node)
@@ -144,12 +145,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 +280,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 +309,20 @@ 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
+
+            check_rescue?(block_body) if block_body.rescue_type?
+          else
+            true
           end
+        end
 
-          true
+        def check_rescue?(rescue_node)
+          rescue_node.body
         end
 
         def skip_check?(base_loc, 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/line_length.rb

@@ -122,8 +122,7 @@ module RuboCop
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
 
-          breakable_range_by_line_index[line_index] =
-            range_between(pos, pos + 1)
+          breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
         end
 
         def breakable_block_range(block_node)
@@ -171,11 +170,7 @@ module RuboCop
           end
           return check_uri_line(line, line_index) if allow_uri?
 
-          register_offense(
-            excess_range(nil, line, line_index),
-            line,
-            line_index
-          )
+          register_offense(excess_range(nil, line, line_index), line, line_index)
         end
 
         def ignored_line?(line, line_index)
@@ -242,9 +237,7 @@ module RuboCop
         end
 
         def line_in_heredoc?(line_number)
-          heredocs.any? do |range, _delimiter|
-            range.cover?(line_number)
-          end
+          heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
         def check_directive_line(line, line_index)
@@ -266,11 +259,7 @@ module RuboCop
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
 
-          register_offense(
-            excess_range(uri_range, line, line_index),
-            line,
-            line_index
-          )
+          register_offense(excess_range(uri_range, line, line_index), line, line_index)
         end
       end
     end

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

@@ -24,8 +24,7 @@ module RuboCop
         include MultilineElementLineBreaks
         extend AutoCorrector
 
-        MSG = 'Each item in a multi-line array must start ' \
-          'on a separate line.'
+        MSG = 'Each item in a multi-line array must start on a separate line.'
 
         def on_array(node)
           check_line_breaks(node, node.children)

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

@@ -52,17 +52,14 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Block body expression is on the same line as ' \
-              'the block start.'
-        ARG_MSG = 'Block argument expression is not on the same line as the ' \
-                  'block start.'
+        MSG = 'Block body expression is on the same line as the block start.'
+        ARG_MSG = 'Block argument expression is not on the same line as the block start.'
         PIPE_SIZE = '|'.length
 
         def on_block(node)
           return if node.single_line?
 
-          unless args_on_beginning_line?(node) ||
-                 line_break_necessary_in_args?(node)
+          unless args_on_beginning_line?(node) || line_break_necessary_in_args?(node)
             add_offense_for_expression(node, node.arguments, ARG_MSG)
           end
 
@@ -74,8 +71,7 @@ module RuboCop
         private
 
         def args_on_beginning_line?(node)
-          !node.arguments? ||
-            node.loc.begin.line == node.arguments.loc.last_line
+          !node.arguments? || node.loc.begin.line == node.arguments.loc.last_line
         end
 
         def line_break_necessary_in_args?(node)
@@ -101,9 +97,7 @@ module RuboCop
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)
 
-          add_offense(range, message: msg) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(range, message: msg) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -128,8 +122,7 @@ module RuboCop
             newlines: false
           ).end_pos
           range = range_between(node.loc.begin.end.begin_pos, end_pos)
-          corrector.replace(range,
-                            " |#{block_arg_string(node, node.arguments)}|")
+          corrector.replace(range, " |#{block_arg_string(node, node.arguments)}|")
         end
 
         def autocorrect_body(corrector, node, block_body)
@@ -141,8 +134,7 @@ module RuboCop
 
           block_start_col = node.source_range.column
 
-          corrector.insert_before(first_node,
-                                  "\n  #{' ' * block_start_col}")
+          corrector.insert_before(first_node, "\n  #{' ' * block_start_col}")
         end
 
         def block_arg_string(node, args)

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

@@ -24,8 +24,7 @@ module RuboCop
         include MultilineElementLineBreaks
         extend AutoCorrector
 
-        MSG = 'Each key in a multi-line hash must start on a ' \
-          'separate line.'
+        MSG = 'Each key in a multi-line hash must start on a separate line.'
 
         def on_hash(node)
           # This cop only deals with hashes wrapped by a set of curly

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

@@ -23,8 +23,7 @@ module RuboCop
         include MultilineElementLineBreaks
         extend AutoCorrector
 
-        MSG = 'Each argument in a multi-line method call must start ' \
-          'on a separate line.'
+        MSG = 'Each argument in a multi-line method call must start on a separate line.'
 
         def on_send(node)
           return if node.method?(:[]=)

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

@@ -46,10 +46,11 @@ module RuboCop
       #                  .a
       #                  .b
       #                  .c
-      class MultilineMethodCallIndentation < Cop
+      class MultilineMethodCallIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        extend AutoCorrector
 
         def validate_config
           return unless style == :aligned && cop_config['IndentationWidth']
@@ -61,16 +62,28 @@ module RuboCop
                 '`EnforcedStyle` is `indented`.'
         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 relevant_node?(send_node)
           send_node.loc.dot # Only check method calls with dot operator
         end
 
+        def 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)
+          end
+        end
+
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
           return false if not_for_this_cop?(node)
@@ -139,8 +152,7 @@ module RuboCop
         def alignment_base(node, rhs, given_style)
           case given_style
           when :aligned
-            semantic_alignment_base(node, rhs) ||
-              syntactic_alignment_base(node, rhs)
+            semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
           when :indented
             nil
           when :indented_relative_to_receiver
@@ -157,15 +169,11 @@ module RuboCop
 
           # a = b
           #     .c
-          part_of_assignment_rhs(lhs, rhs) do |base|
-            return assignment_rhs(base).source_range
-          end
+          part_of_assignment_rhs(lhs, rhs) { |base| return assignment_rhs(base).source_range }
 
           # a + b
           #     .c
-          operation_rhs(lhs) do |base|
-            return base.source_range
-          end
+          operation_rhs(lhs) { |base| return base.source_range }
         end
 
         # a.b
@@ -215,8 +223,7 @@ module RuboCop
         end
 
         def operator_rhs?(node, receiver)
-          node.operator_method? && node.arguments? &&
-            within_node?(receiver, node.first_argument)
+          node.operator_method? && node.arguments? && within_node?(receiver, node.first_argument)
         end
       end
     end

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

@@ -41,10 +41,11 @@ module RuboCop
       #       something_else
       #   end
       #
-      class MultilineOperationIndentation < Cop
+      class MultilineOperationIndentation < Base
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        extend AutoCorrector
 
         def on_and(node)
           check_and_or(node)
@@ -63,12 +64,12 @@ module RuboCop
                                 '`EnforcedStyle` is `indented`.'
         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 relevant_node?(node)
           return false if node.send_type? && node.unary_operation?
 
@@ -117,6 +118,10 @@ module RuboCop
               "spaces for indenting #{what} spanning multiple lines."
           end
         end
+
+        def right_hand_side(send_node)
+          send_node.first_argument.source_range
+        end
       end
     end
   end

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

@@ -68,8 +68,9 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class ParameterAlignment < Cop
+      class ParameterAlignment < Base
         include Alignment
+        extend AutoCorrector
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
           'they span more than one line.'
@@ -84,12 +85,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 message(_node)
           fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
         end