rubocop 0.75.1 → 0.93.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.'
@@ -78,9 +79,7 @@ module RuboCop
           return unless node.square_brackets?
 
           left, right = array_brackets(node)
-          if empty_brackets?(left, right)
-            return empty_offenses(node, left, right, EMPTY_MSG)
-          end
+          return empty_offenses(node, left, right, EMPTY_MSG) if empty_brackets?(left, right)
 
           start_ok = next_to_newline?(node, left)
           end_ok = node.single_line? ? false : end_has_own_line?(right)
@@ -88,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
@@ -125,18 +120,18 @@ 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)
           line, col = line_and_column_for(token)
           return true if col == -1
 
-          processed_source.lines[line][0..col] !~ /\S/
+          !/\S/.match?(processed_source.lines[line][0..col])
         end
 
         def index_for(node, token)
-          tokens(node).index(token)
+          processed_source.tokens_within(node).index(token)
         end
 
         def line_and_column_for(token)
@@ -144,11 +139,12 @@ module RuboCop
         end
 
         def issue_offenses(node, left, right, start_ok, end_ok)
-          if style == :no_space
+          case style
+          when :no_space
             start_ok = next_to_comment?(node, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                       end_ok: end_ok)
-          elsif style == :space
+          when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                    end_ok: end_ok)
           else
@@ -157,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)
@@ -188,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
 
@@ -210,18 +206,21 @@ module RuboCop
 
         def compact_corrections(corrector, node, left, right)
           if qualifies_for_compact?(node, left, side: :left)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
+            compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
           if qualifies_for_compact?(node, right)
-            range = side_space_range(range: right.pos, side: :left)
-            corrector.remove(range)
+            compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
           end
         end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side)
+          corrector.remove(range)
+        end
       end
     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)
@@ -117,7 +107,7 @@ module RuboCop
             range = range_between(left_brace.end_pos, right_brace.begin_pos)
             inner = range.source
 
-            if inner =~ /\S/
+            if /\S/.match?(inner)
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
@@ -142,7 +132,7 @@ module RuboCop
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
-          if inner =~ /\A\S/
+          if /\A\S/.match?(inner)
             no_space_inside_left_brace(left_brace, args_delimiter)
           else
             space_inside_left_brace(left_brace, args_delimiter)
@@ -150,7 +140,7 @@ module RuboCop
         end
 
         def check_right_brace(inner, left_brace, right_brace, single_line)
-          if single_line && inner =~ /\S$/
+          if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else
@@ -216,7 +206,7 @@ module RuboCop
 
         def no_space(begin_pos, end_pos, msg)
           if style == :space
-            offense(begin_pos, end_pos, msg) { opposite_style_detected }
+            offense(begin_pos, end_pos, msg)
           else
             correct_style_detected
           end
@@ -224,15 +214,22 @@ module RuboCop
 
         def space(begin_pos, end_pos, msg)
           if style == :no_space
-            offense(begin_pos, end_pos, msg) { 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,54 +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|
-            # It is possible that BracesAroundHashParameters will remove the
-            # braces while this cop inserts spaces. This can lead to unwanted
-            # changes to the inspected code. If we replace the brace with a
-            # brace plus space (rather than just inserting a space), then any
-            # removal of the same brace will give us a clobbering error. This
-            # in turn will make RuboCop fall back on cop-by-cop
-            # auto-correction. Problem solved.
-            case range.source
-            when /\s/ then corrector.remove(range)
-            when '{' then corrector.replace(range, '{ ')
-            else corrector.replace(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
@@ -142,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
 
@@ -189,7 +164,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
@@ -197,7 +172,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

@@ -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
@@ -72,7 +67,7 @@ module RuboCop
             # If the second token is a comment, that means that a line break
             # follows, and that the rules for space inside don't apply.
             next if token2.comment?
-            next unless token2.line == token1.line && token1.space_after?
+            next unless same_line?(token1, token2) && token1.space_after?
 
             yield range_between(token1.end_pos, token2.begin_pos)
           end
@@ -82,17 +77,18 @@ module RuboCop
           tokens.each_cons(2) do |token1, token2|
             next if can_be_ignored?(token1, token2)
 
-            next unless token2.line == token1.line && !token1.space_after?
-
             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
         end
 
+        def same_line?(token1, token2)
+          token1.line == token2.line
+        end
+
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
@@ -104,8 +100,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          # Ignore empty parens. # TODO: Could be configurable.
-          return true if token1.left_parens? && token2.right_parens?
+          return true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end