rubocop 0.80.0 → 0.84.0

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

@@ -84,7 +84,7 @@ module RuboCop
 
         def on_send(node)
           erb_new_with_non_keyword_arguments(node) do |arguments|
-            return if correct_arguments?(arguments)
+            return if arguments.empty? || correct_arguments?(arguments)
 
             arguments[1..3].each_with_index do |argument, i|
               next if !argument || argument.hash_type?
@@ -141,13 +141,9 @@ 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}"
-          end
+          overridden_kwargs[1] = "eoutvar: #{arguments[3].source}" if arguments[3] && !arguments[3].hash_type?
 
           overridden_kwargs
         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_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

@@ -27,18 +27,20 @@ module RuboCop
       #
       #   # good
       #
-      #   # using while
-      #   while some_condition
+      #   # while replacement
+      #   loop do
       #     do_something
+      #     break unless some_condition
       #   end
       #
       # @example
       #
       #   # good
       #
-      #   # using until
-      #   until some_condition
+      #   # until replacement
+      #   loop do
       #     do_something
+      #     break if some_condition
       #   end
       class Loop < Cop
         MSG = 'Use `Kernel#loop` with `break` rather than ' \

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

@@ -31,14 +31,14 @@ module RuboCop
       #   # good
       #
       #   def foo
-      #     self.class_eval do
+      #     self.class.class_eval do
       #       def bar
       #       end
       #     end
       #   end
       #
       #   def foo
-      #     self.module_exec do
+      #     self.class.module_exec do
       #       def bar
       #       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/parentheses_as_grouped_expression.rb

@@ -9,36 +9,56 @@ 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)
+          return true unless node.arguments.one? && first_argument_starts_with_left_parenthesis?(node)
+
+          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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # 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 ${cbase nil?} :Exception) ... )
+        PATTERN
+
+        def_node_matcher :exception_new_with_message?, <<~PATTERN
+          (send nil? {:raise :fail}
+            (send (const ${cbase nil?} :Exception) :new ... ))
+        PATTERN
+
+        def on_send(node)
+          exception?(node, &check(node)) ||
+            exception_new_with_message?(node, &check(node))
+        end
+
+        private
+
+        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
+  end
+end

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

@@ -26,7 +26,6 @@ module RuboCop
       #   # good
       #   x += 1
       class RedundantCopDisableDirective < Cop
-        include NameSimilarity
         include RangeHelp
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
@@ -235,7 +234,7 @@ module RuboCop
           elsif all_cop_names.include?(cop)
             "`#{cop}`"
           else
-            similar = find_similar_name(cop, [])
+            similar = NameSimilarity.find_similar_name(cop, all_cop_names)
             if similar
               "`#{cop}` (did you mean `#{similar}`?)"
             else
@@ -244,10 +243,6 @@ module RuboCop
           end
         end
 
-        def collect_variable_like_names(scope)
-          all_cop_names.each { |name| scope << name }
-        end
-
         def all_cop_names
           @all_cop_names ||= Cop.registry.names
         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/safe_navigation_chain.rb

@@ -32,7 +32,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $(block (csend ...) ...) $_ ...)
+            (send $({block numblock} (csend ...) ...) $_ ...)
           }
         PATTERN
 

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks unexpected overrides of the `Struct` built-in methods
+      # via `Struct.new`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Struct.new(:members, :clone, :count)
+      #   b = Bad.new([], true, 1)
+      #   b.members #=> [] (overriding `Struct#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.count #=> 1 (overriding `Enumerable#count`)
+      #
+      #   # good
+      #   Good = Struct.new(:id, :name)
+      #   g = Good.new(1, "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<struct Good id=1, name="foo">
+      #   g.count #=> 2
+      #
+      class StructNewOverride < Cop
+        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
+              ' and it may be unexpected.'
+
+        STRUCT_METHOD_NAMES = Struct.instance_methods
+        STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        def_node_matcher :struct_new, <<~PATTERN
+          (send
+            (const ${nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless struct_new(node) do
+            node.arguments.each_with_index do |arg, index|
+              # Ignore if the first argument is a class name
+              next if index.zero? && arg.str_type?
+
+              # Ignore if the argument is not a member name
+              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+
+              member_name = arg.value
+
+              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+              message = format(MSG, member_name: member_name.inspect,
+                                    method_name: member_name.to_s)
+              add_offense(arg, message: message)
+            end
+          end
+        end
+      end
+    end
+  end
+end