rubocop 0.79.0 → 0.83.0

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -51,7 +51,7 @@ module RuboCop
             unless range.resize(1).source == "\n"
               corrector.insert_before(range, ' ' * column_delta)
             end
-          elsif range.source =~ /\A[ \t]+\z/
+          elsif /\A[ \t]+\z/.match?(range.source)
             remove(range, corrector)
           end
         end
@@ -112,7 +112,7 @@ module RuboCop
           corrector.remove(range)
         rescue RuntimeError
           range = range_between(range.begin_pos + 1, range.end_pos + 1)
-          retry if range.source =~ /^ +$/
+          retry if /^ +$/.match?(range.source)
         ensure
           $stderr = original_stderr
         end

data/lib/rubocop/cop/correctors/condition_corrector.rb

@@ -10,8 +10,7 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
-            corrector.replace(condition.source_range,
-                              condition.children.first.source)
+            corrector.replace(condition, condition.children.first.source)
           end
         end
 

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -18,7 +18,7 @@ module RuboCop
         end
 
         def insert_before(node)
-          ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+          ->(corrector) { corrector.insert_before(node, "\n") }
         end
       end
     end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -44,13 +44,13 @@ module RuboCop
       end
 
       def replace_selector(corrector)
-        corrector.replace(method.source_range, 'lambda')
+        corrector.replace(method, 'lambda')
       end
 
       def remove_arguments(corrector)
         return if arguments.empty_and_without_delimiters?
 
-        corrector.remove(arguments.source_range)
+        corrector.remove(arguments)
       end
 
       def insert_arguments(corrector)
@@ -62,7 +62,7 @@ module RuboCop
 
       def remove_leading_whitespace(corrector)
         corrector.remove_preceding(
-          arguments.source_range,
+          arguments,
           arguments.source_range.begin_pos -
             block_node.send_node.source_range.end_pos
         )

data/lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -38,9 +38,9 @@ module RuboCop
           return unless eol_comment
 
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
+          corrector.insert_before(node,
                                   text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
+          corrector.remove(eol_comment)
         end
 
         private

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -26,7 +26,7 @@ module RuboCop
       def wrap_contents(node, contents, char, delimiters)
         lambda do |corrector|
           corrector.replace(
-            node.source_range,
+            node,
             "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
           )
         end

data/lib/rubocop/cop/correctors/string_literal_corrector.rb

@@ -13,9 +13,9 @@ module RuboCop
           lambda do |corrector|
             str = node.str_content
             if style == :single_quotes
-              corrector.replace(node.source_range, to_string_literal(str))
+              corrector.replace(node, to_string_literal(str))
             else
-              corrector.replace(node.source_range, str.inspect)
+              corrector.replace(node, str.inspect)
             end
           end
         end

data/lib/rubocop/cop/generator.rb

@@ -132,11 +132,12 @@ module RuboCop
         ).inject
       end
 
-      def inject_config(config_file_path: 'config/default.yml')
+      def inject_config(config_file_path: 'config/default.yml',
+                        version_added: bump_minor_version)
         injector =
           ConfigurationInjector.new(configuration_file_path: config_file_path,
                                     badge: badge,
-                                    version_added: bump_minor_version)
+                                    version_added: version_added)
 
         injector.inject do
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -28,7 +28,7 @@ module RuboCop
         def autocorrect(node)
           (*, keyword) = offending_location_argument(node.parent)
 
-          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
+          ->(corrector) { corrector.replace(node, ":#{keyword}") }
         end
 
         private

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

@@ -6,33 +6,76 @@ module RuboCop
       # Here we check if the elements of a multi-line array literal are
       # aligned.
       #
-      # @example
+      # @example EnforcedStyle: with_first_element (default)
+      #   # good
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
+      #   array = ['run',
+      #            'forrest',
+      #            'run']
+      #
       #   # bad
-      #   a = [1, 2, 3,
+      #
+      #   array = [1, 2, 3,
       #     4, 5, 6]
       #   array = ['run',
       #        'forrest',
       #        'run']
       #
+      # @example EnforcedStyle: with_fixed_indentation
       #   # good
-      #   a = [1, 2, 3,
-      #        4, 5, 6]
-      #   a = ['run',
-      #        'forrest',
-      #        'run']
+      #
+      #   array = [1, 2, 3,
+      #     4, 5, 6]
+      #
+      #   # bad
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
       class ArrayAlignment < Cop
         include Alignment
 
-        MSG = 'Align the elements of an array literal if they span more ' \
-              'than one line.'
+        ALIGN_ELEMENTS_MSG = 'Align the elements of an array literal ' \
+          'if they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for elements ' \
+          'following the first line of a multi-line array.'
 
         def on_array(node)
-          check_alignment(node.children)
+          return if node.children.size < 2
+
+          check_alignment(node.children, base_column(node, node.children))
         end
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          node.loc.line
+        end
       end
     end
   end

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

@@ -52,9 +52,11 @@ module RuboCop
         end
 
         def delimiter_range(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.children.last.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          Parser::Source::Range.new(
+            node.loc.expression.source_buffer,
+            node.children.compact.last.loc.expression.end_pos,
+            node.loc.expression.end_pos
+          )
         end
       end
     end

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

@@ -23,6 +23,8 @@ module RuboCop
       #     do_something
       #   end
       class ConditionPosition < Cop
+        include RangeHelp
+
         MSG = 'Place the condition on the same line as `%<keyword>s`.'
 
         def on_if(node)
@@ -34,9 +36,17 @@ module RuboCop
         def on_while(node)
           check(node)
         end
+        alias on_until on_while
 
-        def on_until(node)
-          check(node)
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(
+              node.source_range, include_final_newline: true
+            )
+
+            corrector.insert_after(node.parent.loc.keyword, " #{node.source}")
+            corrector.remove(range)
+          end
         end
 
         private

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

@@ -44,7 +44,7 @@ module RuboCop
             when :leading
               corrector.insert_before(selector_range(node), dot)
             when :trailing
-              corrector.insert_after(node.receiver.source_range, dot)
+              corrector.insert_after(node.receiver, dot)
             end
           end
         end

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

@@ -59,6 +59,14 @@ module RuboCop
           check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
         end
 
+        def on_case_match(node)
+          return unless node.else?
+
+          check_alignment(
+            node.in_pattern_branches.last.loc.keyword, node.loc.else
+          )
+        end
+
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end

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

@@ -56,7 +56,8 @@ module RuboCop
           return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
-          add_offense(nodes.last, location: :keyword)
+          location = nodes.last.loc.keyword.join(nodes.last.loc.name)
+          add_offense(nodes.last, location: location)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a newline after attribute accessor.
+      #
+      # @example
+      #   # bad
+      #   attr_accessor :foo
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #   attr_reader :bar
+      #   attr_writer :baz
+      #   attr :qux
+      #
+      #   def do_something
+      #   end
+      #
+      class EmptyLinesAroundAttributeAccessor < Cop
+        include RangeHelp
+
+        MSG = 'Add an empty line after attribute accessor.'
+
+        def on_send(node)
+          return unless node.attribute_accessor?
+          return if next_line_empty?(node.last_line)
+
+          next_line_node = next_line_node(node)
+          return if next_line_node.nil? || attribute_accessor?(next_line_node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(node.source_range)
+
+            corrector.insert_after(range, "\n")
+          end
+        end
+
+        private
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def next_line_node(node)
+          node.parent.children[node.sibling_index + 1]
+        end
+
+        def attribute_accessor?(node)
+          node.send_type? && node.attribute_accessor?
+        end
+      end
+    end
+  end
+end

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

@@ -75,8 +75,8 @@ module RuboCop
                               style
                             end
           case effective_style
-          when :lf then MSG_DETECTED if line =~ /\r$/
-          else MSG_MISSING if line !~ /\r$/
+          when :lf then MSG_DETECTED if /\r$/.match?(line)
+          else MSG_MISSING unless /\r$/.match?(line)
           end
         end
 

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

@@ -125,21 +125,15 @@ module RuboCop
 
         def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
-          return if right_bracket.source_line[0...right_bracket.column] =~ /\S/
+          if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
+            return
+          end
 
           expected_column = base_column(left_bracket, left_parenthesis)
           @column_delta = expected_column - right_bracket.column
           return if @column_delta.zero?
 
-          msg = if style == :align_brackets
-                  'Indent the right bracket the same as the left bracket.'
-                elsif style == :special_inside_parentheses && left_parenthesis
-                  'Indent the right bracket the same as the first position ' \
-                  'after the preceding left parenthesis.'
-                else
-                  'Indent the right bracket the same as the start of the line' \
-                  ' where the left bracket is.'
-                end
+          msg = msg(left_parenthesis)
           add_offense(right_bracket, location: right_bracket, message: msg)
         end
 
@@ -161,6 +155,18 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def msg(left_parenthesis)
+          if style == :align_brackets
+            'Indent the right bracket the same as the left bracket.'
+          elsif style == :special_inside_parentheses && left_parenthesis
+            'Indent the right bracket the same as the first position ' \
+            'after the preceding left parenthesis.'
+          else
+            'Indent the right bracket the same as the start of the line' \
+            ' where the left bracket is.'
+          end
+        end
       end
     end
   end

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

@@ -128,7 +128,7 @@ module RuboCop
 
         def check_right_brace(right_brace, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
-          return if right_brace.source_line[0...right_brace.column] =~ /\S/
+          return if /\S/.match?(right_brace.source_line[0...right_brace.column])
 
           expected_column = base_column(left_brace, left_parenthesis)
           @column_delta = expected_column - right_brace.column

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

@@ -169,7 +169,7 @@ module RuboCop
         end
 
         def add_correct_closing_paren(node, corrector)
-          corrector.insert_after(node.arguments.last.source_range, ')')
+          corrector.insert_after(node.arguments.last, ')')
         end
 
         def remove_incorrect_closing_paren(node, corrector)
@@ -249,7 +249,7 @@ module RuboCop
         def add_correct_external_trailing_comma(node, corrector)
           return unless external_trailing_comma?(node)
 
-          corrector.insert_after(node.arguments.last.source_range, ',')
+          corrector.insert_after(node.arguments.last, ',')
         end
 
         def remove_incorrect_external_trailing_comma(node, corrector)