rubocop 0.82.0 → 1.18.4

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

@@ -63,47 +63,24 @@ module RuboCop
       #   foo = {  }
       #   foo = {     }
       #
-      class SpaceInsideHashLiteralBraces < Cop
+      class SpaceInsideHashLiteralBraces < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Space inside %<problem>s.'
 
         def on_hash(node)
-          tokens = processed_source.tokens
+          tokens = processed_source.tokens_within(node)
+          return unless tokens.first.left_brace? && tokens.last.right_curly_brace?
 
-          hash_literal_with_braces(node) do |begin_index, end_index|
-            check(tokens[begin_index], tokens[begin_index + 1])
-            return if begin_index == end_index - 1
-
-            check(tokens[end_index - 1], tokens[end_index])
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{' then corrector.insert_after(range, ' ')
-            else corrector.insert_before(range, ' ')
-            end
-          end
+          check(tokens[0], tokens[1])
+          check(tokens[-2], tokens[-1]) if tokens.size > 2
         end
 
         private
 
-        def hash_literal_with_braces(node)
-          tokens = processed_source.tokens
-          begin_index = index_of_first_token(node)
-          return unless tokens[begin_index].left_brace?
-
-          end_index = index_of_last_token(node)
-          return unless tokens[end_index].right_curly_brace?
-
-          yield begin_index, end_index
-        end
-
         def check(token1, token2)
           # No offense if line break inside.
           return if token1.line < token2.line
@@ -113,8 +90,7 @@ module RuboCop
           expect_space    = expect_space?(token1, token2)
 
           if offense?(token1, expect_space)
-            incorrect_style_detected(token1, token2,
-                                     expect_space, is_empty_braces)
+            incorrect_style_detected(token1, token2, expect_space, is_empty_braces)
           else
             correct_style_detected
           end
@@ -137,14 +113,19 @@ module RuboCop
                                      expect_space, is_empty_braces)
           brace = (token1.text == '{' ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
-          add_offense(
-            range,
-            location: range,
-            message: message(brace, is_empty_braces, expect_space)
-          ) do
-            style = expect_space ? :no_space : :space
-            ambiguous_or_unexpected_style_detected(style,
-                                                   token1.text == token2.text)
+          detected_style = expect_space ? 'no_space' : 'space'
+
+          add_offense(range, message: message(brace, is_empty_braces, expect_space)) do |corrector|
+            autocorrect(corrector, range)
+            ambiguous_or_unexpected_style_detected(detected_style, token1.text == token2.text)
+          end
+        end
+
+        def autocorrect(corrector, range)
+          case range.source
+          when /\s/ then corrector.remove(range)
+          when '{' then corrector.insert_after(range, ' ')
+          else corrector.insert_before(range, ' ')
           end
         end
 
@@ -182,7 +163,7 @@ module RuboCop
         def range_of_space_to_the_right(range)
           src = range.source_buffer.source
           end_pos = range.end_pos
-          end_pos += 1 while src[end_pos] =~ /[ \t]/
+          end_pos += 1 while /[ \t]/.match?(src[end_pos])
 
           range_between(range.begin_pos + 1, end_pos)
         end
@@ -190,7 +171,7 @@ module RuboCop
         def range_of_space_to_the_left(range)
           src = range.source_buffer.source
           begin_pos = range.begin_pos
-          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
+          begin_pos -= 1 while /[ \t]/.match?(src[begin_pos - 1])
 
           range_between(begin_pos, range.end_pos - 1)
         end

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

@@ -11,10 +11,12 @@ module RuboCop
       #   # bad
       #   f( 3)
       #   g = (a + 3 )
+      #   f( )
       #
       #   # good
       #   f(3)
       #   g = (a + 3)
+      #   f()
       #
       # @example EnforcedStyle: space
       #   # The `space` style enforces that parentheses have a space at the
@@ -31,40 +33,46 @@ module RuboCop
       #   g = ( a + 3 )
       #   y()
       #
-      class SpaceInsideParens < Cop
+      class SpaceInsideParens < Base
         include SurroundingSpace
         include RangeHelp
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG       = 'Space inside parentheses detected.'
         MSG_SPACE = 'No space inside parentheses detected.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           @processed_source = processed_source
 
           if style == :space
-            each_missing_space(processed_source.tokens) do |range|
-              add_offense(range, location: range, message: MSG_SPACE)
-            end
+            process_with_space_style(processed_source)
           else
             each_extraneous_space(processed_source.tokens) do |range|
-              add_offense(range, location: range)
+              add_offense(range) do |corrector|
+                corrector.remove(range)
+              end
             end
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            if style == :space
-              corrector.insert_before(range, ' ')
-            else
-              corrector.remove(range)
+        private
+
+        def process_with_space_style(processed_source)
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            each_extraneous_space_in_empty_parens(token1, token2) do |range|
+              add_offense(range) do |corrector|
+                corrector.remove(range)
+              end
+            end
+            each_missing_space(token1, token2) do |range|
+              add_offense(range, message: MSG_SPACE) do |corrector|
+                corrector.insert_before(range, ' ')
+              end
             end
           end
         end
 
-        private
-
         def each_extraneous_space(tokens)
           tokens.each_cons(2) do |token1, token2|
             next unless parens?(token1, token2)
@@ -78,15 +86,21 @@ module RuboCop
           end
         end
 
-        def each_missing_space(tokens)
-          tokens.each_cons(2) do |token1, token2|
-            next if can_be_ignored?(token1, token2)
+        def each_extraneous_space_in_empty_parens(token1, token2)
+          return unless token1.left_parens? && token2.right_parens?
 
-            if token1.left_parens?
-              yield range_between(token2.begin_pos, token2.begin_pos + 1)
-            elsif token2.right_parens?
-              yield range_between(token2.begin_pos, token2.end_pos)
-            end
+          return if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
+          yield range_between(token1.end_pos, token2.begin_pos)
+        end
+
+        def each_missing_space(token1, token2)
+          return if can_be_ignored?(token1, token2)
+
+          if token1.left_parens?
+            yield range_between(token2.begin_pos, token2.begin_pos + 1)
+          elsif token2.right_parens?
+            yield range_between(token2.begin_pos, token2.end_pos)
           end
         end
 
@@ -101,6 +115,9 @@ module RuboCop
         def can_be_ignored?(token1, token2)
           return true unless parens?(token1, token2)
 
+          # Ignore empty parentheses.
+          return true if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
           # If the second token is a comment, that means that a line break
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?

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

@@ -16,9 +16,10 @@ module RuboCop
       #
       #   # bad
       #   %x(  ls -l )
-      class SpaceInsidePercentLiteralDelimiters < Cop
+      class SpaceInsidePercentLiteralDelimiters < Base
         include MatchRange
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Do not use spaces inside percent literal delimiters.'
         BEGIN_REGEX = /\A( +)/.freeze
@@ -36,21 +37,15 @@ module RuboCop
           add_offenses_for_unnecessary_spaces(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            regex_matches(node) do |match_range|
-              corrector.remove(match_range)
-            end
-          end
-        end
-
         private
 
         def add_offenses_for_unnecessary_spaces(node)
           return unless node.single_line?
 
           regex_matches(node) do |match_range|
-            add_offense(node, location: match_range)
+            add_offense(match_range) do |corrector|
+              corrector.remove(match_range)
+            end
           end
         end
 

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

@@ -17,7 +17,9 @@ module RuboCop
       #
       #   # good
       #   'a'..'z'
-      class SpaceInsideRangeLiteral < Cop
+      class SpaceInsideRangeLiteral < Base
+        extend AutoCorrector
+
         MSG = 'Space inside range literal.'
 
         def on_irange(node)
@@ -28,21 +30,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          expression = node.source
-          operator = node.loc.operator.source
-          operator_escaped = operator.gsub(/\./, '\.')
-
-          lambda do |corrector|
-            corrector.replace(
-              node,
-              expression
-                .sub(/\s+#{operator_escaped}/, operator)
-                .sub(/#{operator_escaped}\s+/, operator)
-            )
-          end
-        end
-
         private
 
         def check(node)
@@ -55,7 +42,11 @@ module RuboCop
 
           return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(
+              node, expression.sub(/\s+#{escaped_op}/, op).sub(/#{escaped_op}\s+/, op)
+            )
+          end
         end
       end
     end

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

@@ -53,20 +53,20 @@ module RuboCop
       #   # good
       #   foo[ ]
       #
-      class SpaceInsideReferenceBrackets < Cop
+      class SpaceInsideReferenceBrackets < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '%<command>s space inside reference brackets.'
         EMPTY_MSG = '%<command>s space inside empty reference brackets.'
 
-        BRACKET_METHODS = %i[[] []=].freeze
+        RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
           return if node.multiline?
-          return unless bracket_method?(node)
 
-          tokens = tokens(node)
+          tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
 
@@ -83,40 +83,31 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = reference_brackets(node)
-
-            if empty_brackets?(left, right)
-              SpaceCorrector.empty_corrections(processed_source, corrector,
-                                               empty_config, left, right)
-            elsif style == :no_space
-              SpaceCorrector.remove_space(processed_source, corrector,
-                                          left, right)
-            else
-              SpaceCorrector.add_space(processed_source, corrector, left, right)
-            end
+        private
+
+        def autocorrect(corrector, node)
+          left, right = reference_brackets(node)
+
+          if empty_brackets?(left, right)
+            SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
+          elsif style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, left, right)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, left, right)
           end
         end
 
-        private
-
         def reference_brackets(node)
-          tokens = tokens(node)
+          tokens = processed_source.tokens_within(node)
           left = left_ref_bracket(node, tokens)
           [left, closing_bracket(tokens, left)]
         end
 
-        def bracket_method?(node)
-          BRACKET_METHODS.include?(node.method_name)
-        end
-
         def left_ref_bracket(node, tokens)
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)
 
-          if node.method?(:[]=) ||
-             previous_token && !previous_token.right_bracket?
+          if node.method?(:[]=) || previous_token && !previous_token.right_bracket?
             tokens.find(&:left_ref_bracket?)
           else
             current_token
@@ -130,9 +121,7 @@ module RuboCop
           tokens[i..-1].each do |token|
             inner_left_brackets_needing_closure += 1 if token.left_bracket?
             inner_left_brackets_needing_closure -= 1 if token.right_bracket?
-            if inner_left_brackets_needing_closure.zero? && token.right_bracket?
-              return token
-            end
+            return token if inner_left_brackets_needing_closure.zero? && token.right_bracket?
           end
         end
 

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

@@ -18,11 +18,12 @@ module RuboCop
       #
       #   # good
       #      var = "This is the #{ space } example"
-      class SpaceInsideStringInterpolation < Cop
+      class SpaceInsideStringInterpolation < Base
         include Interpolation
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'
         SPACE_MSG = 'Missing space inside string interpolation detected.'
@@ -40,23 +41,21 @@ module RuboCop
           end
         end
 
-        def autocorrect(begin_node)
-          lambda do |corrector|
-            delims = delimiters(begin_node)
+        private
+
+        def autocorrect(corrector, begin_node)
+          delims = delimiters(begin_node)
 
-            if style == :no_space
-              SpaceCorrector.remove_space(processed_source, corrector, *delims)
-            else
-              SpaceCorrector.add_space(processed_source, corrector, *delims)
-            end
+          if style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, *delims)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, *delims)
           end
         end
 
-        private
-
         def delimiters(begin_node)
-          left = processed_source.tokens[index_of_first_token(begin_node)]
-          right = processed_source.tokens[index_of_last_token(begin_node)]
+          left = processed_source.first_token_of(begin_node)
+          right = processed_source.last_token_of(begin_node)
           [left, right]
         end
       end

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

@@ -37,11 +37,12 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingEmptyLines < Cop
+      class TrailingEmptyLines < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        def investigate(processed_source)
+        def on_new_investigation
           buffer = processed_source.buffer
           return if buffer.source.empty?
 
@@ -57,28 +58,22 @@ module RuboCop
 
           return unless blank_lines != wanted_blank_lines
 
-          offense_detected(buffer, wanted_blank_lines, blank_lines,
-                           whitespace_at_end)
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
-          end
+          offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
         end
 
         private
 
-        def offense_detected(buffer, wanted_blank_lines, blank_lines,
-                             whitespace_at_end)
+        def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
           begin_pos = buffer.source.length - whitespace_at_end.length
           autocorrect_range = range_between(begin_pos, buffer.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
           report_range = range_between(begin_pos, buffer.source.length)
 
-          add_offense(autocorrect_range,
-                      location: report_range,
-                      message: message(wanted_blank_lines, blank_lines))
+          add_offense(
+            report_range, message: message(wanted_blank_lines, blank_lines)
+          ) do |corrector|
+            corrector.replace(autocorrect_range, style == :final_newline ? "\n" : "\n\n")
+          end
         end
 
         def ends_in_end?(processed_source)