rubocop 0.81.0 → 0.85.1

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

@@ -141,9 +141,7 @@ module RuboCop
           arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          if arguments[2]
-            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
-          end
+          overridden_kwargs[0] = "trim_mode: #{arguments[2].source}" if arguments[2]
 
           if arguments[3] && !arguments[3].hash_type?
             overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"

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

@@ -7,6 +7,10 @@ module RuboCop
       # expected fields for format/sprintf/#% and what is actually
       # passed as arguments.
       #
+      # In addition it checks whether different formats are used in the same
+      # format string. Do not mix numbered, unnumbered, and named formats in
+      # the same format string.
+      #
       # @example
       #
       #   # bad
@@ -18,16 +22,37 @@ module RuboCop
       #   # good
       #
       #   format('A value: %s and another: %i', a_value, another)
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('Unnumbered format: %s and numbered: %2$s', a_value, another)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('Numbered format: %1$s and numbered %2$s', a_value, another)
       class FormatParameterMismatch < Cop
         # http://rubular.com/r/CvpbxkcTzy
         MSG = "Number of arguments (%<arg_num>i) to `%<method>s` doesn't " \
               'match the number of fields (%<field_num>i).'
+        MSG_INVALID = 'Format string is invalid because formatting sequence types ' \
+                      '(numbered, named or unnumbered) are mixed.'
 
         KERNEL = 'Kernel'
         SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
 
         def on_send(node)
+          return unless format_string?(node)
+
+          if invalid_format_string?(node)
+            add_offense(node, location: :selector, message: MSG_INVALID)
+            return
+          end
+
           return unless offending_node?(node)
 
           add_offense(node, location: :selector)
@@ -35,9 +60,15 @@ module RuboCop
 
         private
 
+        def format_string?(node)
+          called_on_string?(node) && method_with_format_args?(node)
+        end
+
+        def invalid_format_string?(node)
+          !RuboCop::Cop::Utils::FormatString.new(node.source).valid?
+        end
+
         def offending_node?(node)
-          return false unless called_on_string?(node)
-          return false unless method_with_format_args?(node)
           return false if splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)

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_as_condition.rb

@@ -10,26 +10,25 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if 20
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad
-      #
       #   if some_var && true
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if some_var && some_condition
       #     do_something
       #   end
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   end
       class LiteralAsCondition < Cop
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
@@ -38,20 +37,18 @@ module RuboCop
         end
 
         def on_while(node)
-          check_for_literal(node)
-        end
+          return if condition(node).true_type?
 
-        def on_while_post(node)
           check_for_literal(node)
         end
+        alias on_while_post on_while
 
         def on_until(node)
-          check_for_literal(node)
-        end
+          return if condition(node).false_type?
 
-        def on_until_post(node)
           check_for_literal(node)
         end
+        alias on_until_post on_until
 
         def on_case(case_node)
           if case_node.condition

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/loop.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for uses of *begin...end while/until something*.
+      # This cop checks for uses of `begin...end while/until something`.
       #
       # @example
       #

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not mix named captures and numbered captures in a Regexp literal
+      # because numbered capture is ignored if they're mixed.
+      # Replace numbered captures with non-capturing groupings or
+      # named captures.
+      #
+      #   # bad
+      #   /(?<foo>FOO)(BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?<bar>BAR)/
+      #
+      #   # good
+      #   /(?<foo>FOO)(?:BAR)/
+      #
+      #   # good
+      #   /(FOO)(BAR)/
+      #
+      class MixedRegexpCaptureTypes < Cop
+        MSG = 'Do not mix named captures and numbered captures ' \
+              'in a Regexp literal.'
+
+        def on_regexp(node)
+          return if contain_non_literal?(node)
+
+          begin
+            tree = Regexp::Parser.parse(node.content)
+          # Returns if a regular expression that cannot be processed by regexp_parser gem.
+          # https://github.com/rubocop-hq/rubocop/issues/8083
+          rescue Regexp::Scanner::ScannerError
+            return
+          end
+
+          return unless named_capture?(tree)
+          return unless numbered_capture?(tree)
+
+          add_offense(node)
+        end
+
+        private
+
+        def contain_non_literal?(node)
+          if node.respond_to?(:type) && (node.variable? || node.send_type? || node.const_type?)
+            return true
+          end
+          return false unless node.respond_to?(:children)
+
+          node.children.any? { |child| contain_non_literal?(child) }
+        end
+
+        def named_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Capture)
+          end
+        end
+
+        def numbered_capture?(tree)
+          tree.each_expression.any? do |e|
+            e.instance_of?(Regexp::Expression::Group::Named)
+          end
+        end
+      end
+    end
+  end
+end

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/nested_percent_literal.rb

@@ -42,7 +42,7 @@ module RuboCop
         def contains_percent_literals?(node)
           node.each_child_node.any? do |child|
             literal = child.children.first.to_s.scrub
-            REGEXES.any? { |regex| literal.match(regex) }
+            REGEXES.any? { |regex| literal.match?(regex) }
           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/non_local_exit_from_iterator.rb

@@ -6,13 +6,13 @@ module RuboCop
       # This cop checks for non-local exits from iterators without a return
       # value. It registers an offense under these conditions:
       #
-      #  - No value is returned,
-      #  - the block is preceded by a method chain,
-      #  - the block has arguments,
-      #  - the method which receives the block is not `define_method`
-      #    or `define_singleton_method`,
-      #  - the return is not contained in an inner scope, e.g. a lambda or a
-      #    method definition.
+      # * No value is returned,
+      # * the block is preceded by a method chain,
+      # * the block has arguments,
+      # * the method which receives the block is not `define_method`
+      # or `define_singleton_method`,
+      # * the return is not contained in an inner scope, e.g. a lambda or a
+      # method definition.
       #
       # @example
       #

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/parentheses_as_grouped_expression.rb

@@ -9,36 +9,58 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
-      #   puts (x + y)
-      #
-      # @example
+      #   do_something (foo)
       #
       #   # good
-      #
-      #   puts(x + y)
+      #   do_something(foo)
+      #   do_something (2 + 3) * 4
+      #   do_something (foo * bar).baz
       class ParenthesesAsGroupedExpression < Cop
         include RangeHelp
 
         MSG = '`(...)` interpreted as grouped expression.'
 
         def on_send(node)
-          return unless node.arguments.one?
-          return if node.operator_method? || node.setter_method?
-
-          return unless node.first_argument.source.start_with?('(')
+          return if valid_context?(node)
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length.positive?
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(nil, location: range)
+          add_offense(node, location: range)
         end
         alias on_csend on_send
 
+        def autocorrect(node)
+          space_length = spaces_before_left_parenthesis(node)
+          range = space_range(node.first_argument.source_range, space_length)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         private
 
+        def valid_context?(node)
+          unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
+            return true
+          end
+
+          node.operator_method? || node.setter_method? || grouped_parentheses?(node)
+        end
+
+        def first_argument_starts_with_left_parenthesis?(node)
+          node.first_argument.source.start_with?('(')
+        end
+
+        def grouped_parentheses?(node)
+          first_argument = node.first_argument
+
+          first_argument.send_type? && first_argument.receiver&.begin_type?
+        end
+
         def spaces_before_left_parenthesis(node)
           receiver = node.receiver
           receiver_length = if receiver

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

@@ -42,15 +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
-                corrector.remove_leading(range, 1)
-              end
+              corrector.remove_leading(range, 1) if LEADING_QUOTE.match?(range.source)
             end
           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