rubocop 0.81.0 → 0.82.0

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

@@ -56,7 +56,7 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.each_comment do |comment|
-            next unless comment.text =~ /\A#+[^#\s=:+-]/
+            next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)

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

@@ -8,7 +8,7 @@ module RuboCop
       # This cop checks the length of lines in the source code.
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
-      # of the `Layout/Tab` cop.
+      # of the `Layout/IndentationStyle` cop.
       # It also ignores a shebang line by default.
       #
       # This cop has some autocorrection capabilities.
@@ -145,7 +145,7 @@ module RuboCop
           return nil unless next_range.line == range.line
 
           next_char = next_range.source
-          return nil if /[\r\n]/ =~ next_char
+          return nil if /[\r\n]/.match?(next_char)
           return nil if next_char == ';'
 
           next_range

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

@@ -129,7 +129,7 @@ module RuboCop
 
           block_start_col = node.source_range.column
 
-          corrector.insert_before(first_node.source_range,
+          corrector.insert_before(first_node,
                                   "\n  #{' ' * block_start_col}")
         end
 

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

@@ -43,11 +43,11 @@ module RuboCop
           lambda do |corrector|
             if target.is_a?(RuboCop::AST::Node)
               if target.parent.children.first == target
-                corrector.insert_before(target.source_range, ' ')
+                corrector.insert_before(target, ' ')
               else
-                corrector.insert_after(target.source_range, ' ')
+                corrector.insert_after(target, ' ')
               end
-            elsif target.source =~ /^\s+$/
+            elsif /^\s+$/.match?(target.source)
               corrector.remove(target)
             else
               corrector.insert_after(target, ' ')

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks method call operators to not have spaces around them.
+      #
+      # @example
+      #   # bad
+      #   foo. bar
+      #   foo .bar
+      #   foo . bar
+      #   foo. bar .buzz
+      #   foo
+      #     . bar
+      #     . buzz
+      #   foo&. bar
+      #   foo &.bar
+      #   foo &. bar
+      #   foo &. bar&. buzz
+      #   RuboCop:: Cop
+      #   RuboCop:: Cop:: Cop
+      #   :: RuboCop::Cop
+      #
+      #   # good
+      #   foo.bar
+      #   foo.bar.buzz
+      #   foo
+      #     .bar
+      #     .buzz
+      #   foo&.bar
+      #   foo&.bar&.buzz
+      #   RuboCop::Cop
+      #   RuboCop::Cop::Cop
+      #   ::RuboCop::Cop
+      #
+      class SpaceAroundMethodCallOperator < Cop
+        include SurroundingSpace
+
+        MSG = 'Avoid using spaces around a method call operator.'
+
+        def on_send(node)
+          return unless dot_or_safe_navigation_operator?(node)
+
+          check_and_add_offense(node)
+        end
+
+        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
+        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
+        end
+
+        def operator_token(node)
+          operator_location =
+            node.const_type? ? node.loc.double_colon : node.loc.dot
+
+          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
+
+        def dot_or_safe_navigation_operator?(node)
+          node.dot? || node.safe_navigation?
+        end
+
+        def valid_left_token?(left, operator)
+          left && left.line == operator.line
+        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 right_token_for_auto_correction(operator)
+          right_token = next_token(operator)
+          if !right_token.comment? && valid_right_token?(right_token, operator)
+            return right_token
+          end
+
+          operator
+        end
+      end
+    end
+  end
+end

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

@@ -175,7 +175,7 @@ module RuboCop
             return if with_space.is?(operator.source)
 
             "Space around operator `#{operator.source}` detected."
-          elsif with_space.source !~ /^\s.*\s$/
+          elsif !/^\s.*\s$/.match?(with_space.source)
             "Surrounding space missing for operator `#{operator.source}`."
           elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)

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

@@ -46,7 +46,7 @@ module RuboCop
           children = lambda_node.parent.children
           lambda do |corrector|
             if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
+              corrector.insert_before(children[1], ' ')
             else
               corrector.remove(space_after_arrow(lambda_node))
             end

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

@@ -117,7 +117,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 +142,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)

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

@@ -35,7 +35,7 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(
-              node.source_range,
+              node,
               expression
                 .sub(/\s+#{operator_escaped}/, operator)
                 .sub(/#{operator_escaped}\s+/, operator)
@@ -53,7 +53,7 @@ module RuboCop
           # account for multiline range literals
           expression.sub!(/#{escaped_op}\n\s*/, op)
 
-          return unless expression =~ /(\s#{escaped_op})|(#{escaped_op}\s)/
+          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
 
           add_offense(node)
         end

data/lib/rubocop/cop/lint/boolean_symbol.rb

@@ -37,11 +37,11 @@ module RuboCop
           lambda do |corrector|
             boolean_literal = node.source.delete(':')
             parent = node.parent
-            if parent&.pair_type?
+            if parent&.pair_type? && node.equal?(parent.children[0])
               corrector.remove(parent.loc.operator)
               boolean_literal = "#{node.source} =>"
             end
-            corrector.replace(node.loc.expression, boolean_literal)
+            corrector.replace(node, boolean_literal)
           end
         end
       end

data/lib/rubocop/cop/lint/debugger.rb

@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def binding_irb?(node)
-          target_ruby_version >= 2.4 && binding_irb_call?(node)
+          binding_irb_call?(node)
         end
       end
     end

data/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def display_str(node)
-          if node.source =~ /\n/
+          if /\n/.match?(node.source)
             str_content(node).inspect
           else
             node.source

data/lib/rubocop/cop/lint/inherit_exception.rb

@@ -77,7 +77,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, preferred_base_class)
+            corrector.replace(node, preferred_base_class)
           end
         end
 

data/lib/rubocop/cop/lint/interpolation_check.rb

@@ -25,7 +25,7 @@ module RuboCop
 
           parent = node.parent
           return if parent && (parent.dstr_type? || parent.regexp_type?)
-          return unless node.source.scrub =~ /(?<!\\)#\{.*\}/
+          return unless /(?<!\\)#\{.*\}/.match?(node.source.scrub)
 
           add_offense(node)
         end

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -37,7 +37,7 @@ module RuboCop
           return if node.dstr_type? # nested, fixed in next iteration
 
           value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent.source_range, value) }
+          ->(corrector) { corrector.replace(node.parent, value) }
         end
 
         private

data/lib/rubocop/cop/lint/multiple_comparison.rb

@@ -39,7 +39,7 @@ module RuboCop
           new_center = "#{center.source} && #{center.source}"
 
           lambda do |corrector|
-            corrector.replace(center.source_range, new_center)
+            corrector.replace(center, new_center)
           end
         end
       end

data/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -52,12 +52,12 @@ module RuboCop
         def autocorrect(node)
           if unsorted_dir_block?(node)
             lambda do |corrector|
-              corrector.replace(node.loc.expression, "#{node.source}.sort.each")
+              corrector.replace(node, "#{node.source}.sort.each")
             end
           else
             lambda do |corrector|
               source = node.receiver.source
-              corrector.replace(node.loc.expression, "#{source}.sort.each")
+              corrector.replace(node, "#{source}.sort.each")
             end
           end
         end

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -55,7 +55,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression,
+            corrector.replace(node,
                               correct_method(node, node.receiver))
           end
         end

data/lib/rubocop/cop/lint/percent_string_array.rb

@@ -42,13 +42,13 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            node.values.each do |value|
+            node.each_value do |value|
               range = value.loc.expression
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match
 
-              if range.source =~ LEADING_QUOTE
+              if LEADING_QUOTE.match?(range.source)
                 corrector.remove_leading(range, 1)
               end
             end

data/lib/rubocop/cop/lint/raise_exception.rb

@@ -6,32 +6,68 @@ module RuboCop
       # This cop checks for `raise` or `fail` statements which are
       # raising `Exception` class.
       #
+      # You can specify a module name that will be an implicit namespace
+      # using `AllowedImplicitNamespaces` option. The cop cause a false positive
+      # for namespaced `Exception` when a namespace is omitted. This option can
+      # prevent the false positive by specifying a namespace to be omitted for
+      # `Exception`. Alternatively, make `Exception` a fully qualified class
+      # name with an explicit namespace.
+      #
       # @example
       #   # bad
       #   raise Exception, 'Error message here'
       #
       #   # good
       #   raise StandardError, 'Error message here'
+      #
+      # @example AllowedImplicitNamespaces: ['Gem']
+      #   # good
+      #   module Gem
+      #     def self.foo
+      #       raise Exception # This exception means `Gem::Exception`.
+      #     end
+      #   end
       class RaiseException < Cop
         MSG = 'Use `StandardError` over `Exception`.'
 
         def_node_matcher :exception?, <<~PATTERN
-          (send nil? ${:raise :fail} (const _ :Exception) ... )
+          (send nil? {:raise :fail} (const ${cbase nil?} :Exception) ... )
         PATTERN
 
         def_node_matcher :exception_new_with_message?, <<~PATTERN
-          (send nil? ${:raise :fail}
-            (send (const _ :Exception) :new ... ))
+          (send nil? {:raise :fail}
+            (send (const ${cbase nil?} :Exception) :new ... ))
         PATTERN
 
         def on_send(node)
-          add_offense(node) if raise_exception?(node)
+          exception?(node, &check(node)) ||
+            exception_new_with_message?(node, &check(node))
         end
 
         private
 
-        def raise_exception?(node)
-          exception?(node) || exception_new_with_message?(node)
+        def check(node)
+          lambda do |cbase|
+            return if cbase.nil? && implicit_namespace?(node)
+
+            add_offense(node)
+          end
+        end
+
+        def implicit_namespace?(node)
+          return false unless (parent = node.parent)
+
+          if parent.module_type?
+            namespace = parent.identifier.source
+
+            return allow_implicit_namespaces.include?(namespace)
+          end
+
+          implicit_namespace?(parent)
+        end
+
+        def allow_implicit_namespaces
+          cop_config['AllowedImplicitNamespaces'] || []
         end
       end
     end

data/lib/rubocop/cop/lint/redundant_string_coercion.rb

@@ -38,7 +38,7 @@ module RuboCop
           lambda do |corrector|
             receiver = node.receiver
             corrector.replace(
-              node.source_range,
+              node,
               if receiver
                 receiver.source
               else

data/lib/rubocop/cop/lint/unified_integer.rb

@@ -33,8 +33,6 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return false if target_ruby_version <= 2.3
-
           lambda do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end