rubocop 0.87.0 → 0.90.0

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

@@ -24,7 +24,9 @@ module RuboCop
       #   end
       #
       #   something = 123 if test
-      class SpaceAroundKeyword < Cop
+      class SpaceAroundKeyword < Base
+        extend AutoCorrector
+
         MSG_BEFORE = 'Space before keyword `%<range>s` is missing.'
         MSG_AFTER = 'Space after keyword `%<range>s` is missing.'
 
@@ -129,14 +131,6 @@ module RuboCop
           check(node, [:keyword].freeze)
         end
 
-        def autocorrect(range)
-          if space_before_missing?(range)
-            ->(corrector) { corrector.insert_before(range, ' ') }
-          else
-            ->(corrector) { corrector.insert_after(range, ' ') }
-          end
-        end
-
         private
 
         def check(node, locations, begin_keyword = DO)
@@ -162,8 +156,11 @@ module RuboCop
 
         def check_end(node, range, begin_keyword)
           return if begin_keyword == DO && !do?(node)
+          return unless space_before_missing?(range)
 
-          offense(range, MSG_BEFORE) if space_before_missing?(range)
+          add_offense(range, message: format(MSG_BEFORE, range: range.source)) do |corrector|
+            corrector.insert_before(range, ' ')
+          end
         end
 
         def do?(node)
@@ -171,15 +168,17 @@ module RuboCop
         end
 
         def check_keyword(node, range)
-          offense(range, MSG_BEFORE) if space_before_missing?(range) &&
-                                        !preceded_by_operator?(node, range)
-          offense(range, MSG_AFTER) if space_after_missing?(range)
-        end
+          if space_before_missing?(range) && !preceded_by_operator?(node, range)
+            add_offense(range, message: format(MSG_BEFORE, range: range.source)) do |corrector|
+              corrector.insert_before(range, ' ')
+            end
+          end
 
-        def offense(range, msg)
-          add_offense(range,
-                      location: range,
-                      message: format(msg, range: range.source))
+          return unless space_after_missing?(range)
+
+          add_offense(range, message: format(MSG_AFTER, range: range.source)) do |corrector|
+            corrector.insert_after(range, ' ')
+          end
         end
 
         def space_before_missing?(range)

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

@@ -34,96 +34,63 @@ module RuboCop
       #   RuboCop::Cop::Cop
       #   ::RuboCop::Cop
       #
-      class SpaceAroundMethodCallOperator < Cop
-        include SurroundingSpace
+      class SpaceAroundMethodCallOperator < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        SPACES_REGEXP = /\A[ \t]+\z/.freeze
 
         MSG = 'Avoid using spaces around a method call operator.'
 
         def on_send(node)
-          return unless dot_or_safe_navigation_operator?(node)
+          return unless node.dot? || node.safe_navigation?
 
-          check_and_add_offense(node)
+          check_space_before_dot(node)
+          check_space_after_dot(node)
         end
+        alias on_csend on_send
 
         def on_const(node)
           return unless node.loc.double_colon
 
-          check_and_add_offense(node, false)
-        end
-
-        def autocorrect(node)
-          operator = operator_token(node)
-          left = left_token_for_auto_correction(node, operator)
-          right = right_token_for_auto_correction(operator)
-
-          lambda do |corrector|
-            SpaceCorrector.remove_space(
-              processed_source, corrector, left, right
-            )
-          end
+          check_space_after_double_colon(node)
         end
 
-        alias on_csend on_send
-
         private
 
-        def check_and_add_offense(node, add_left_offense = true)
-          operator = operator_token(node)
-          left = previous_token(operator)
-          right = next_token(operator)
-
-          if !right.comment? && valid_right_token?(right, operator)
-            no_space_offenses(node, operator, right, MSG)
-          end
-          return unless valid_left_token?(left, operator)
-
-          no_space_offenses(node, left, operator, MSG) if add_left_offense
+        def check_space_before_dot(node)
+          receiver_pos = node.receiver.source_range.end_pos
+          dot_pos = node.loc.dot.begin_pos
+          check_space(receiver_pos, dot_pos)
         end
 
-        def operator_token(node)
-          operator_location =
-            node.const_type? ? node.loc.double_colon : node.loc.dot
+        def check_space_after_dot(node)
+          dot_pos = node.loc.dot.end_pos
 
-          processed_source.find_token do |token|
-            token.pos == operator_location
-          end
-        end
-
-        def previous_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
-        end
-
-        def next_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          processed_source.tokens[index + 1]
-        end
+          selector_pos =
+            # `Proc#call` shorthand syntax
+            if node.method?(:call) && !node.loc.selector
+              node.loc.begin.begin_pos
+            else
+              node.loc.selector.begin_pos
+            end
 
-        def dot_or_safe_navigation_operator?(node)
-          node.dot? || node.safe_navigation?
+          check_space(dot_pos, selector_pos)
         end
 
-        def valid_left_token?(left, operator)
-          left && left.line == operator.line
+        def check_space_after_double_colon(node)
+          double_colon_pos = node.loc.double_colon.end_pos
+          name_pos = node.loc.name.begin_pos
+          check_space(double_colon_pos, name_pos)
         end
 
-        def valid_right_token?(right, operator)
-          right && right.line == operator.line
-        end
-
-        def left_token_for_auto_correction(node, operator)
-          left_token = previous_token(operator)
-          return operator if node.const_type?
-          return left_token if valid_left_token?(left_token, operator)
-
-          operator
-        end
+        def check_space(begin_pos, end_pos)
+          return if end_pos <= begin_pos
 
-        def right_token_for_auto_correction(operator)
-          right_token = next_token(operator)
-          return right_token if !right_token.comment? && valid_right_token?(right_token, operator)
+          range = range_between(begin_pos, end_pos)
+          return unless range.source.match?(SPACES_REGEXP)
 
-          operator
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
       end
     end

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

@@ -48,10 +48,11 @@ module RuboCop
       #
       #   # good
       #   a ** b
-      class SpaceAroundOperators < Cop
+      class SpaceAroundOperators < Base
         include PrecedingFollowingAlignment
         include RangeHelp
         include RationalLiteral
+        extend AutoCorrector
 
         IRREGULAR_METHODS = %i[[] ! []=].freeze
         EXCESSIVE_SPACE = '  '
@@ -132,18 +133,6 @@ module RuboCop
         alias on_and_asgn on_assignment
         alias on_op_asgn  on_special_asgn
 
-        def autocorrect(range)
-          lambda do |corrector|
-            if /\*\*/.match?(range.source) && !space_around_exponent_operator?
-              corrector.replace(range, '**')
-            elsif range.source.end_with?("\n")
-              corrector.replace(range, " #{range.source.strip}\n")
-            else
-              enclose_operator_with_space(corrector, range)
-            end
-          end
-        end
-
         private
 
         def regular_operator?(send_node)
@@ -161,7 +150,9 @@ module RuboCop
           return if with_space.source.start_with?("\n")
 
           offense(type, operator, with_space, right_operand) do |msg|
-            add_offense(with_space, location: operator, message: msg)
+            add_offense(operator, message: msg) do |corrector|
+              autocorrect(corrector, with_space)
+            end
           end
         end
 
@@ -170,14 +161,24 @@ module RuboCop
           yield msg if msg
         end
 
+        def autocorrect(corrector, range)
+          if /\*\*/.match?(range.source) && !space_around_exponent_operator?
+            corrector.replace(range, '**')
+          elsif range.source.end_with?("\n")
+            corrector.replace(range, " #{range.source.strip}\n")
+          else
+            enclose_operator_with_space(corrector, range)
+          end
+        end
+
         def enclose_operator_with_space(corrector, range)
           operator = range.source
 
           # If `ForceEqualSignAlignment` is true, `Layout/ExtraSpacing` cop
           # inserts spaces before operator. If `Layout/SpaceAroundOperators` cop
           # inserts a space, it collides and raises the infinite loop error.
-          if force_equal_sign_alignment?
-            corrector.insert_after(range, ' ') unless operator.end_with?(' ')
+          if force_equal_sign_alignment? && !operator.end_with?(' ')
+            corrector.insert_after(range, ' ')
           else
             corrector.replace(range, " #{operator.strip} ")
           end

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