rubocop 1.9.0 → 1.12.1

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

@@ -74,7 +74,7 @@ module RuboCop
       #   else 250
       #   end
       #
-      # @example IgnoreLiteralBranches: true
+      # @example IgnoreConstantBranches: true
       #   # good
       #   case size
       #   when "small" then SMALL_SIZE

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

@@ -82,6 +82,7 @@ module RuboCop
           end
         end
 
+        # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
           (alias (sym $_name) sym)
         PATTERN
@@ -94,10 +95,12 @@ module RuboCop
           found_instance_method(node, name)
         end
 
+        # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
+        # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
         def on_send(node)
           if (name = alias_method?(node))

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

@@ -21,11 +21,12 @@ module RuboCop
       #
       class DuplicateRequire < Base
         MSG = 'Duplicate `%<method>s` detected.'
-        REQUIRE_METHODS = %i[require require_relative].freeze
+        REQUIRE_METHODS = Set.new(%i[require require_relative]).freeze
         RESTRICT_ON_SEND = REQUIRE_METHODS
 
+        # @!method require_call?(node)
         def_node_matcher :require_call?, <<~PATTERN
-          (send {nil? (const _ :Kernel)} {:#{REQUIRE_METHODS.join(' :')}} _)
+          (send {nil? (const _ :Kernel)} %REQUIRE_METHODS _)
         PATTERN
 
         def on_new_investigation

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

@@ -25,6 +25,7 @@ module RuboCop
         MSG = 'The argument to each_with_object cannot be immutable.'
         RESTRICT_ON_SEND = %i[each_with_object].freeze
 
+        # @!method each_with_object?(node)
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)
         PATTERN

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

@@ -47,7 +47,7 @@ module RuboCop
         MSG = 'Odd `else` layout detected. Did you mean to use `elsif`?'
 
         def on_if(node)
-          return if node.ternary? || node.elsif?
+          return if node.ternary?
 
           check(node)
         end

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

@@ -80,6 +80,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method erb_new_with_non_keyword_arguments(node)
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)

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

@@ -92,6 +92,7 @@ module RuboCop
           end
         end
 
+        # @!method called_on_string?(node)
         def_node_matcher :called_on_string?, <<~PATTERN
           {(send {nil? const_type?} _ (str _) ...)
            (send (str ...) ...)}

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

@@ -24,6 +24,7 @@ module RuboCop
 
         MSG = 'Use `Hash#compare_by_identity` instead of using `object_id` for keys.'
 
+        # @!method id_as_hash_key?(node)
         def_node_matcher :id_as_hash_key?, <<~PATTERN
           (send _ {:key? :has_key? :fetch :[] :[]=} (send _ :object_id) ...)
         PATTERN

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

@@ -53,6 +53,7 @@ module RuboCop
         ALTERNATIVE_PROTECTED = '`protected` inside a `class << self` ' \
                                 'block'
 
+        # @!method private_class_methods(node)
         def_node_search :private_class_methods, <<~PATTERN
           (send nil? :private_class_method $...)
         PATTERN

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

@@ -58,6 +58,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method class_new_call?(node)
         def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new

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

@@ -11,14 +11,10 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   x < y < z
       #   10 <= x <= 20
       #
-      # @example
-      #
       #   # good
-      #
       #   x < y && y < z
       #   10 <= x && x <= 20
       class MultipleComparison < Base
@@ -26,14 +22,19 @@ module RuboCop
 
         MSG = 'Use the `&&` operator to compare multiple values.'
         COMPARISON_METHODS = %i[< > <= >=].freeze
+        SET_OPERATION_OPERATORS = %i[& | ^].freeze
         RESTRICT_ON_SEND = COMPARISON_METHODS
 
+        # @!method multiple_compare?(node)
         def_node_matcher :multiple_compare?, <<~PATTERN
           (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN
 
         def on_send(node)
           return unless (center = multiple_compare?(node))
+          # It allows multiple comparison using `&`, `|`, and `^` set operation operators.
+          # e.g. `x >= y & y < z`
+          return if center.send_type? && SET_OPERATION_OPERATORS.include?(center.method_name)
 
           add_offense(node) do |corrector|
             new_center = "#{center.source} && #{center.source}"

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

@@ -81,14 +81,17 @@ module RuboCop
             class_or_module_or_struct_new_call?(child)
         end
 
+        # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        # @!method exec_call?(node)
         def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
+        # @!method class_or_module_or_struct_new_call?(node)
         def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
           (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
         PATTERN

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

@@ -25,6 +25,7 @@ module RuboCop
       class NextWithoutAccumulator < Base
         MSG = 'Use `next` with an accumulator argument in a `reduce`.'
 
+        # @!method on_body_of_reduce(node)
         def_node_matcher :on_body_of_reduce, <<~PATTERN
           (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
         PATTERN

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

@@ -129,32 +129,39 @@ module RuboCop
           unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
         end
 
+        # @!method unsorted_dir_block?(node)
         def_node_matcher :unsorted_dir_block?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...)
         PATTERN
 
+        # @!method unsorted_dir_each?(node)
         def_node_matcher :unsorted_dir_each?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
         PATTERN
 
+        # @!method method_require?(node)
         def_node_matcher :method_require?, <<~PATTERN
           (block-pass (send nil? :method (sym :require)))
         PATTERN
 
+        # @!method unsorted_dir_glob_pass?(node)
         def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
           (send (const {nil? cbase} :Dir) :glob ...
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method unsorted_dir_each_pass?(node)
         def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
           (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
             (block-pass (send nil? :method (sym :require))))
         PATTERN
 
+        # @!method loop_variable(node)
         def_node_matcher :loop_variable, <<~PATTERN
           (args (arg $_))
         PATTERN
 
+        # @!method var_is_required?(node, name)
         def_node_search :var_is_required?, <<~PATTERN
           (send nil? :require (lvar %1))
         PATTERN

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

@@ -73,7 +73,10 @@ module RuboCop
           !return_node.children.empty?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -58,14 +58,16 @@ module RuboCop
         }.freeze
         MSG = 'Replace unsafe number conversion with number '\
               'class parsing, instead of using '\
-              '%<current>s, use stricter '\
-              '%<corrected_method>s.'
+              '`%<current>s`, use stricter '\
+              '`%<corrected_method>s`.'
         METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
 
+        # @!method to_method(node)
         def_node_matcher :to_method, <<~PATTERN
           (send $_ ${#{METHODS}})
         PATTERN
 
+        # @!method to_method_symbol(node)
         def_node_matcher :to_method_symbol, <<~PATTERN
           {(send _ $_ ${(sym ${#{METHODS}})} ...)
            (send _ $_ ${(block_pass (sym ${#{METHODS}}))} ...)}
@@ -103,6 +105,8 @@ module RuboCop
               corrected_method: correct_sym_method(to_method)
             )
             add_offense(node, message: message) do |corrector|
+              remove_parentheses(corrector, node) if node.parenthesized?
+
               corrector.replace(sym_node, correct_sym_method(to_method))
             end
           end
@@ -118,6 +122,11 @@ module RuboCop
           "{ |i| #{body} }"
         end
 
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.loc.begin, ' ')
+          corrector.remove(node.loc.end)
+        end
+
         def ignore_receiver?(receiver)
           if receiver.send_type? && ignored_method?(receiver.method_name)
             true

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

@@ -33,10 +33,12 @@ module RuboCop
         MSG = 'Use `StandardError` over `Exception`.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method exception?(node)
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )
         PATTERN
 
+        # @!method exception_new_with_message?(node)
         def_node_matcher :exception_new_with_message?, <<~PATTERN
           (send nil? {:raise :fail}
             (send $(const ${cbase nil?} :Exception) :new ... ))

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

@@ -25,6 +25,7 @@ module RuboCop
               'Perhaps you meant `rand(2)` or `rand`?'
         RESTRICT_ON_SEND = %i[rand].freeze
 
+        # @!method rand_one?(node)
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN

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

@@ -174,8 +174,7 @@ module RuboCop
         end
 
         def directive_count(comment)
-          match = comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
-          _, cops_string = match.captures
+          _, cops_string = DirectiveComment.new(comment).match_captures
           cops_string.split(/,\s*/).size
         end
 

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

@@ -28,6 +28,7 @@ module RuboCop
         MSG = 'Remove unnecessary `require` statement.'
         RESTRICT_ON_SEND = %i[require].freeze
 
+        # @!method unnecessary_require_statement?(node)
         def_node_matcher :unnecessary_require_statement?, <<~PATTERN
           (send nil? :require
             (str {"enumerator" "rational" "complex" "thread"}))

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

@@ -43,6 +43,7 @@ module RuboCop
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
 
+        # @!method respond_to_nil_specific_method?(node)
         def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
           (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
         PATTERN

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

@@ -79,6 +79,7 @@ module RuboCop
         PERCENT_CAPITAL_I = '%I'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
+        # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN
           {
             $(send (const {nil? cbase} :Array) :new ...)
@@ -86,6 +87,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method literal_expansion(node)
         def_node_matcher :literal_expansion, <<~PATTERN
           (splat {$({str dstr int float array} ...) (block $#array_new? ...) $#array_new?} ...)
         PATTERN
@@ -140,13 +142,15 @@ module RuboCop
         def replacement_range_and_content(node)
           variable, = *node
           loc = node.loc
+          expression = loc.expression
 
           if array_new?(variable)
-            [node.parent.loc.expression, variable.source]
+            expression = node.parent.loc.expression if node.parent.array_type?
+            [expression, variable.source]
           elsif !variable.array_type?
-            [loc.expression, "[#{variable.source}]"]
+            [expression, "[#{variable.source}]"]
           elsif redundant_brackets?(node)
-            [loc.expression, remove_brackets(variable)]
+            [expression, remove_brackets(variable)]
           else
             [loc.operator, '']
           end

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

@@ -25,6 +25,7 @@ module RuboCop
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'
 
+        # @!method to_s_without_args?(node)
         def_node_matcher :to_s_without_args?, '(send _ :to_s)'
 
         def on_interpolation(begin_node)

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

@@ -33,6 +33,7 @@ module RuboCop
         MSG_EACH_WITH_INDEX = 'Use `each` instead of `each_with_index`.'
         MSG_WITH_INDEX = 'Remove redundant `with_index`.'
 
+        # @!method redundant_with_index?(node)
         def_node_matcher :redundant_with_index?, <<~PATTERN
           (block
             $(send

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

@@ -34,6 +34,7 @@ module RuboCop
 
         MSG_WITH_OBJECT = 'Remove redundant `with_object`.'
 
+        # @!method redundant_with_object?(node)
         def_node_matcher :redundant_with_object?, <<~PATTERN
           (block
             $(send _ {:each_with_object :with_object}

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

@@ -29,6 +29,7 @@ module RuboCop
         MSG = 'Do not chain ordinary method call' \
               ' after safe navigation operator.'
 
+        # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)

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

@@ -25,6 +25,7 @@ module RuboCop
         MSG = 'Avoid calling `empty?` with the safe navigation operator ' \
           'in conditionals.'
 
+        # @!method safe_navigation_empty_in_conditional?(node)
         def_node_matcher :safe_navigation_empty_in_conditional?, <<~PATTERN
           (if (csend (send ...) :empty?) ...)
         PATTERN

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

@@ -43,6 +43,7 @@ module RuboCop
         SEND_METHODS = %i[send public_send __send__].freeze
         RESTRICT_ON_SEND = SEND_METHODS
 
+        # @!method send_with_mixin_argument?(node)
         def_node_matcher :send_with_mixin_argument?, <<~PATTERN
           (send
             (const _ _) {:#{SEND_METHODS.join(' :')}}

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

@@ -67,6 +67,7 @@ module RuboCop
         MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
               'before it was used.'
 
+        # @!method uses_var?(node)
         def_node_search :uses_var?, '(lvar %)'
 
         def self.joining_forces

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

@@ -42,6 +42,7 @@ module RuboCop
       class ShadowingOuterLocalVariable < Base
         MSG = 'Shadowing outer local variable - `%<variable>s`.'
 
+        # @!method ractor_block?(node)
         def_node_matcher :ractor_block?, <<~PATTERN
           (block (send (const nil? :Ractor) :new ...) ...)
         PATTERN

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

@@ -29,6 +29,7 @@ module RuboCop
         STRUCT_METHOD_NAMES = Struct.instance_methods
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
 
+        # @!method struct_new(node)
         def_node_matcher :struct_new, <<~PATTERN
           (send
             (const ${nil? cbase} :Struct) :new ...)

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

@@ -64,12 +64,51 @@ module RuboCop
       #   rescue
       #     # do nothing
       #   end
+      #
+      # @example AllowNil: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   do_something rescue nil
+      #
+      # @example AllowNil: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   do_something rescue nil
       class SuppressedException < Base
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
-          return if node.body
+          return if node.body && !nil_body?(node)
           return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+          return if cop_config['AllowNil'] && nil_body?(node)
 
           add_offense(node)
         end
@@ -83,6 +122,10 @@ module RuboCop
           end_line = ancestor.loc.end.line
           processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
         end
+
+        def nil_body?(node)
+          node.body&.nil_type?
+        end
       end
     end
   end