rubocop 0.89.1 → 0.90.0

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

@@ -41,9 +41,10 @@ module RuboCop
       #
       #   # good
       #   7.times{}
-      class SpaceBeforeBlockBraces < Cop
+      class SpaceBeforeBlockBraces < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MISSING_MSG = 'Space missing to the left of {.'
         DETECTED_MSG = 'Space detected to the left of {.'
@@ -75,29 +76,22 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            case range.source
-            when /\s/ then corrector.remove(range)
-            else           corrector.insert_before(range, ' ')
-            end
-          end
-        end
-
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)
           return if style_for_empty_braces == used_style
 
-          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] =
-            used_style.to_s
+          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
 
           if style_for_empty_braces == :space
-            add_offense(left_brace, location: left_brace, message: MISSING_MSG)
+            add_offense(left_brace, message: MISSING_MSG) do |corrector|
+              autocorrect(corrector, left_brace)
+            end
           else
-            space = range_between(space_plus_brace.begin_pos,
-                                  left_brace.begin_pos)
-            add_offense(space, location: space, message: DETECTED_MSG)
+            space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+            add_offense(space, message: DETECTED_MSG) do |corrector|
+              autocorrect(corrector, space)
+            end
           end
         end
 
@@ -110,16 +104,23 @@ module RuboCop
         end
 
         def space_missing(left_brace)
-          add_offense(left_brace, location: left_brace, message: MISSING_MSG) do
-            opposite_style_detected
+          add_offense(left_brace, message: MISSING_MSG) do |corrector|
+            autocorrect(corrector, left_brace)
           end
         end
 
         def space_detected(left_brace, space_plus_brace)
-          space = range_between(space_plus_brace.begin_pos,
-                                left_brace.begin_pos)
-          add_offense(space, location: space, message: DETECTED_MSG) do
-            opposite_style_detected
+          space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+
+          add_offense(space, message: DETECTED_MSG) do |corrector|
+            autocorrect(corrector, space)
+          end
+        end
+
+        def autocorrect(corrector, range)
+          case range.source
+          when /\s/ then corrector.remove(range)
+          else           corrector.insert_before(range, ' ')
           end
         end
 

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

@@ -15,12 +15,10 @@ module RuboCop
       #   [1, 2, 3]
       #   a(1, 2)
       #   each { |a, b| }
-      class SpaceBeforeComma < Cop
+      #
+      class SpaceBeforeComma < Base
         include SpaceBeforePunctuation
-
-        def autocorrect(space)
-          PunctuationCorrector.remove_space(space)
-        end
+        extend AutoCorrector
 
         def kind(token)
           'comma' if token.comma?

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

@@ -12,20 +12,23 @@ module RuboCop
       #
       #   # good
       #   1 + 1 # this operation does ...
-      class SpaceBeforeComment < Cop
+      class SpaceBeforeComment < Base
+        extend AutoCorrector
+
         MSG = 'Put a space before an end-of-line comment.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.tokens.each_cons(2) do |token1, token2|
             next unless token2.comment?
             next unless token1.line == token2.line
+            next unless token1.pos.end == token2.pos.begin
 
-            add_offense(token2.pos, location: token2.pos) if token1.pos.end == token2.pos.begin
-          end
-        end
+            range = token2.pos
 
-        def autocorrect(range)
-          ->(corrector) { corrector.insert_before(range, ' ') }
+            add_offense(range) do |corrector|
+              corrector.insert_before(range, ' ')
+            end
+          end
         end
       end
     end

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

@@ -21,31 +21,31 @@ module RuboCop
       #   something y, z
       #   something 'hello'
       #
-      class SpaceBeforeFirstArg < Cop
+      class SpaceBeforeFirstArg < Base
         include PrecedingFollowingAlignment
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Put one space between the method name and ' \
               'the first argument.'
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
-          return unless expect_params_after_method_name?(node)
 
           first_arg = node.first_argument.source_range
           first_arg_with_space = range_with_surrounding_space(range: first_arg,
                                                               side: :left)
           space = range_between(first_arg_with_space.begin_pos,
                                 first_arg.begin_pos)
+          return if space.length == 1
+          return unless expect_params_after_method_name?(node)
 
-          add_offense(space, location: space) if space.length != 1
+          add_offense(space) do |corrector|
+            corrector.replace(space, ' ')
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(range)
-          ->(corrector) { corrector.replace(range, ' ') }
-        end
-
         private
 
         def regular_method_call_with_arguments?(node)

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

@@ -11,12 +11,9 @@ module RuboCop
       #
       #   # good
       #   x = 1; y = 2
-      class SpaceBeforeSemicolon < Cop
+      class SpaceBeforeSemicolon < Base
         include SpaceBeforePunctuation
-
-        def autocorrect(space)
-          PunctuationCorrector.remove_space(space)
-        end
+        extend AutoCorrector
 
         def kind(token)
           'semicolon' if token.semicolon?

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

@@ -19,9 +19,10 @@ module RuboCop
       #
       #     # good
       #     a = -> (x, y) { x + y }
-      class SpaceInLambdaLiteral < Cop
+      class SpaceInLambdaLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
                             '`(` in lambda literals.'
@@ -31,24 +32,15 @@ module RuboCop
         def on_send(node)
           return unless arrow_lambda_with_args?(node)
 
+          lambda_node = range_of_offense(node)
+
           if style == :require_space && !space_after_arrow?(node)
-            add_offense(node,
-                        location: range_of_offense(node),
-                        message: MSG_REQUIRE_SPACE)
+            add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
+              corrector.insert_before(node.parent.children[1], ' ')
+            end
           elsif style == :require_no_space && space_after_arrow?(node)
-            add_offense(node,
-                        location: range_of_offense(node),
-                        message: MSG_REQUIRE_NO_SPACE)
-          end
-        end
-
-        def autocorrect(lambda_node)
-          children = lambda_node.parent.children
-          lambda do |corrector|
-            if style == :require_space
-              corrector.insert_before(children[1], ' ')
-            else
-              corrector.remove(space_after_arrow(lambda_node))
+            add_offense(lambda_node, message: MSG_REQUIRE_NO_SPACE) do |corrector|
+              corrector.remove(space_after_arrow(node))
             end
           end
         end

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,26 +87,22 @@ 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

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,10 +63,11 @@ module RuboCop
       #   foo = {  }
       #   foo = {     }
       #
-      class SpaceInsideHashLiteralBraces < Cop
+      class SpaceInsideHashLiteralBraces < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Space inside %<problem>s.'
 
@@ -81,16 +82,6 @@ module RuboCop
           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
-        end
-
         private
 
         def hash_literal_with_braces(node)
@@ -137,14 +128,20 @@ 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)
+
+          style = expect_space ? :no_space : :space
+          return unless 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