rubocop 0.88.0 → 0.91.1

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

@@ -67,9 +67,10 @@ module RuboCop
       #   foo = [ ]
       #   bar = [ ]
       #
-      class SpaceInsideArrayLiteralBrackets < Cop
+      class SpaceInsideArrayLiteralBrackets < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '%<command>s space inside array brackets.'
         EMPTY_MSG = '%<command>s space inside empty array brackets.'
@@ -86,36 +87,32 @@ module RuboCop
           issue_offenses(node, left, right, start_ok, end_ok)
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           left, right = array_brackets(node)
 
-          lambda do |corrector|
-            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)
-            elsif style == :space
-              SpaceCorrector.add_space(processed_source, corrector, left, right)
-            else
-              compact_corrections(corrector, node, left, right)
-            end
+          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)
+          elsif style == :space
+            SpaceCorrector.add_space(processed_source, corrector, left, right)
+          else
+            compact_corrections(corrector, node, left, right)
           end
         end
 
-        private
-
         def array_brackets(node)
           [left_array_bracket(node), right_array_bracket(node)]
         end
 
         def left_array_bracket(node)
-          tokens(node).find(&:left_array_bracket?)
+          processed_source.tokens_within(node).find(&:left_array_bracket?)
         end
 
         def right_array_bracket(node)
-          tokens(node).reverse.find(&:right_bracket?)
+          processed_source.tokens_within(node).reverse.find(&:right_bracket?)
         end
 
         def empty_config
@@ -123,7 +120,7 @@ module RuboCop
         end
 
         def next_to_newline?(node, token)
-          tokens(node)[index_for(node, token) + 1].line != token.line
+          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
         end
 
         def end_has_own_line?(token)
@@ -134,7 +131,7 @@ module RuboCop
         end
 
         def index_for(node, token)
-          tokens(node).index(token)
+          processed_source.tokens_within(node).index(token)
         end
 
         def line_and_column_for(token)
@@ -156,7 +153,7 @@ module RuboCop
         end
 
         def next_to_comment?(node, token)
-          tokens(node)[index_for(node, token) + 1].comment?
+          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
         end
 
         def compact_offenses(node, left, right, start_ok, end_ok)
@@ -187,9 +184,9 @@ module RuboCop
         def multi_dimensional_array?(node, token, side: :right)
           i = index_for(node, token)
           if side == :right
-            tokens(node)[i - 1].right_bracket?
+            processed_source.tokens_within(node)[i - 1].right_bracket?
           else
-            tokens(node)[i + 1].left_array_bracket?
+            processed_source.tokens_within(node)[i + 1].left_array_bracket?
           end
         end
 

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

@@ -12,9 +12,10 @@ module RuboCop
       #   %w(foo  bar  baz)
       #   # good
       #   %i(foo bar baz)
-      class SpaceInsideArrayPercentLiteral < Cop
+      class SpaceInsideArrayPercentLiteral < Base
         include MatchRange
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Use only a single space inside array percent literal.'
         MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
@@ -26,13 +27,7 @@ module RuboCop
 
         def on_percent_literal(node)
           each_unnecessary_space_match(node) do |range|
-            add_offense(node, location: range)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            each_unnecessary_space_match(node) do |range|
+            add_offense(range) do |corrector|
               corrector.replace(range, ' ')
             end
           end

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

@@ -76,10 +76,11 @@ module RuboCop
       #   # good
       #   [1, 2, 3].each {|n| n * 2 }
       #
-      class SpaceInsideBlockBraces < Cop
+      class SpaceInsideBlockBraces < Base
         include ConfigurableEnforcedStyle
         include SurroundingSpace
         include RangeHelp
+        extend AutoCorrector
 
         def on_block(node)
           return if node.keywords?
@@ -97,17 +98,6 @@ module RuboCop
           check_inside(node, left_brace, right_brace)
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{}' then corrector.replace(range, '{ }')
-            when '{|' then corrector.replace(range, '{ |')
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-
         private
 
         def check_inside(node, left_brace, right_brace)
@@ -216,7 +206,9 @@ module RuboCop
 
         def no_space(begin_pos, end_pos, msg)
           if style == :space
-            offense(begin_pos, end_pos, msg) { opposite_style_detected }
+            return unless opposite_style_detected
+
+            offense(begin_pos, end_pos, msg)
           else
             correct_style_detected
           end
@@ -224,15 +216,24 @@ module RuboCop
 
         def space(begin_pos, end_pos, msg)
           if style == :no_space
-            offense(begin_pos, end_pos, msg) { opposite_style_detected }
+            return unless opposite_style_detected
+
+            offense(begin_pos, end_pos, msg)
           else
             correct_style_detected
           end
         end
 
-        def offense(begin_pos, end_pos, msg, &block)
+        def offense(begin_pos, end_pos, msg)
           range = range_between(begin_pos, end_pos)
-          add_offense(range, location: range, message: msg, &block)
+          add_offense(range, message: msg) do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            when '{}' then corrector.replace(range, '{ }')
+            when '{|' then corrector.replace(range, '{ |')
+            else           corrector.insert_before(range, ' ')
+            end
+          end
         end
 
         def style_for_empty_braces

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
@@ -135,16 +112,21 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
+          return unless ambiguous_or_unexpected_style_detected(style, token1.text == token2.text)
+
           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)
+
+          add_offense(range, message: message(brace, is_empty_braces, expect_space)) do |corrector|
+            autocorrect(corrector, range)
+          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
 

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

@@ -31,34 +31,29 @@ 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)
+              add_offense(range, message: MSG_SPACE) do |corrector|
+                corrector.insert_before(range, ' ')
+              end
             end
           else
             each_extraneous_space(processed_source.tokens) do |range|
-              add_offense(range, location: range)
-            end
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            if style == :space
-              corrector.insert_before(range, ' ')
-            else
-              corrector.remove(range)
+              add_offense(range) do |corrector|
+                corrector.remove(range)
+              end
             end
           end
         end

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,34 +83,26 @@ 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)