rubocop 1.20.0 → 1.21.0

data/lib/rubocop/cop/style/empty_method.rb

@@ -62,7 +62,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          compact_style? && compact?(node) || expanded_style? && expanded?(node)
+          (compact_style? && compact?(node)) || (expanded_style? && expanded?(node))
         end
 
         def corrected(node)

data/lib/rubocop/cop/style/explicit_block_argument.rb

@@ -67,17 +67,27 @@ module RuboCop
             # so this can cause crashes in haml_lint
             return unless def_node
 
+            block_name = extract_block_name(def_node)
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
-              add_block_argument(send_node, corrector)
-              add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
+              add_block_argument(send_node, corrector, block_name)
+              add_block_argument(def_node, corrector, block_name) if @def_nodes.add?(def_node)
             end
           end
         end
 
         private
 
+        def extract_block_name(def_node)
+          if def_node.block_argument?
+            def_node.arguments.last.name
+          else
+            'block'
+          end
+        end
+
         def yielding_arguments?(block_args, yield_args)
           yield_args = yield_args.dup.fill(
             nil,
@@ -91,15 +101,15 @@ module RuboCop
           end
         end
 
-        def add_block_argument(node, corrector)
+        def add_block_argument(node, corrector, block_name)
           if node.arguments?
-            insert_argument(node, corrector)
+            insert_argument(node, corrector, block_name)
           elsif empty_arguments?(node)
-            corrector.replace(node.arguments, '(&block)')
+            corrector.replace(node.arguments, "(&#{block_name})")
           elsif call_like?(node)
-            correct_call_node(node, corrector)
+            correct_call_node(node, corrector, block_name)
           else
-            corrector.insert_after(node.loc.name, '(&block)')
+            corrector.insert_after(node.loc.name, "(&#{block_name})")
           end
         end
 
@@ -112,16 +122,16 @@ module RuboCop
           node.call_type? || node.zsuper_type? || node.super_type?
         end
 
-        def insert_argument(node, corrector)
+        def insert_argument(node, corrector, block_name)
           last_arg = node.arguments.last
           arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-          replacement = ' &block'
+          replacement = " &#{block_name}"
           replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
           corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
         end
 
-        def correct_call_node(node, corrector)
-          corrector.insert_after(node, '(&block)')
+        def correct_call_node(node, corrector, block_name)
+          corrector.insert_after(node, "(&#{block_name})")
           return unless node.parenthesized?
 
           args_begin = Util.args_begin(node)

data/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb

@@ -109,12 +109,13 @@ module RuboCop
         end
 
         def opposite_condition?(node)
-          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+          (!node.unless? && node.if_branch.false_type?) ||
+            (node.unless? && node.if_branch.true_type?)
         end
 
         def require_parentheses?(condition)
           condition.and_type? || condition.or_type? ||
-            condition.send_type? && condition.comparison_method?
+            (condition.send_type? && condition.comparison_method?)
         end
       end
     end

data/lib/rubocop/cop/style/lambda_call.rb

@@ -52,7 +52,7 @@ module RuboCop
         private
 
         def offense?(node)
-          explicit_style? && node.implicit_call? || implicit_style? && !node.implicit_call?
+          (explicit_style? && node.implicit_call?) || (implicit_style? && !node.implicit_call?)
         end
 
         def message(_node)

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -93,8 +93,8 @@ module RuboCop
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
             parent &&
               (logical_operator?(parent) ||
-              parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) })
+              (parent.send_type? &&
+              parent.arguments.any? { |argument| logical_operator?(argument) }))
           end
 
           def call_in_optional_arguments?(node)
@@ -122,14 +122,14 @@ module RuboCop
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
+              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
               node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
             node.arguments.any? do |n|
               hash_literal?(n) ||
-                n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) }
+                (n.send_type? && node.descendants.any? { |descendant| hash_literal?(descendant) })
             end
           end
 
@@ -171,8 +171,8 @@ module RuboCop
           end
 
           def unary_literal?(node)
-            node.numeric_type? && node.sign? ||
-              node.parent&.send_type? && node.parent&.unary_operation?
+            (node.numeric_type? && node.sign?) ||
+              (node.parent&.send_type? && node.parent&.unary_operation?)
           end
 
           def assigned_before?(node, target)

data/lib/rubocop/cop/style/mutable_constant.rb

@@ -153,7 +153,7 @@ module RuboCop
         def check(value)
           range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
           return unless mutable_literal?(value) ||
-                        target_ruby_version <= 2.7 && range_enclosed_in_parentheses
+                        (target_ruby_version <= 2.7 && range_enclosed_in_parentheses)
 
           return if frozen_string_literal?(value)
           return if shareable_constant_value?(value)

data/lib/rubocop/cop/style/negated_if.rb

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

data/lib/rubocop/cop/style/negated_unless.rb

@@ -80,7 +80,7 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :prefix && node.modifier_form? || style == :postfix && !node.modifier_form?
+          (style == :prefix && node.modifier_form?) || (style == :postfix && !node.modifier_form?)
         end
       end
     end

data/lib/rubocop/cop/style/non_nil_check.rb

@@ -63,7 +63,7 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node) ||
-                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+                    (!include_semantic_changes? && nil_comparison_style == 'comparison')
           return unless register_offense?(node)
 
           message = message(node)
@@ -87,7 +87,7 @@ module RuboCop
 
         def register_offense?(node)
           not_equal_to_nil?(node) ||
-            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            (include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node)))
         end
 
         def autocorrect(corrector, node)

data/lib/rubocop/cop/style/not.rb

@@ -53,8 +53,8 @@ module RuboCop
 
         def requires_parens?(child)
           child.and_type? || child.or_type? ||
-            child.send_type? && child.binary_operation? ||
-            child.if_type? && child.ternary?
+            (child.send_type? && child.binary_operation?) ||
+            (child.if_type? && child.ternary?)
         end
 
         def correct_opposite_method(corrector, range, child)

data/lib/rubocop/cop/style/parallel_assignment.rb

@@ -153,7 +153,7 @@ module RuboCop
 
           def dependency?(lhs, rhs)
             uses_var?(rhs, var_name(lhs)) ||
-              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
           end
 
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.

data/lib/rubocop/cop/style/percent_q_literals.rb

@@ -53,8 +53,8 @@ module RuboCop
         end
 
         def correct_literal_style?(node)
-          style == :lower_case_q && type(node) == '%q' ||
-            style == :upper_case_q && type(node) == '%Q'
+          (style == :lower_case_q && type(node) == '%q') ||
+            (style == :upper_case_q && type(node) == '%Q')
         end
 
         def message(_range)

data/lib/rubocop/cop/style/raise_args.rb

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def requires_parens?(parent)
-          parent.and_type? || parent.or_type? || parent.if_type? && parent.ternary?
+          parent.and_type? || parent.or_type? || (parent.if_type? && parent.ternary?)
         end
       end
     end

data/lib/rubocop/cop/style/redundant_condition.rb

@@ -120,11 +120,10 @@ module RuboCop
         end
 
         def require_parentheses?(node)
-          node.basic_conditional? &&
-            node.modifier_form? ||
+          (node.basic_conditional? && node.modifier_form?) ||
             node.range_type? ||
             node.rescue_type? ||
-            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+            (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
         def without_argument_parentheses_method?(node)

data/lib/rubocop/cop/style/redundant_interpolation.rb

@@ -56,7 +56,7 @@ module RuboCop
           first_child = node.children.first
 
           variable_interpolation?(first_child) ||
-            first_child.send_type? && !first_child.operator_method?
+            (first_child.send_type? && !first_child.operator_method?)
         end
 
         def interpolation?(node)

data/lib/rubocop/cop/style/redundant_percent_q.rb

@@ -65,9 +65,8 @@ module RuboCop
         end
 
         def allowed_percent_q?(node)
-          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
-            node.source.start_with?(PERCENT_CAPITAL_Q) &&
-              acceptable_capital_q?(node)
+          (node.source.start_with?(PERCENT_Q) && acceptable_q?(node)) ||
+            (node.source.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node))
         end
 
         def message(node)

data/lib/rubocop/cop/style/redundant_self_assignment_branch.rb

@@ -58,7 +58,7 @@ module RuboCop
 
         def inconvertible_to_modifier?(if_branch, else_branch)
           multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
-            else_branch.respond_to?(:elsif?) && else_branch.elsif?
+            (else_branch.respond_to?(:elsif?) && else_branch.elsif?)
         end
 
         def multiple_statements?(branch)

data/lib/rubocop/cop/style/redundant_sort.rb

@@ -76,13 +76,30 @@ module RuboCop
 
         def on_send(node)
           if (sort_node, sorter, accessor = redundant_sort?(node.parent))
+            return if use_size_method_in_block?(sort_node)
+
             ancestor = node.parent
           elsif (sort_node, sorter, accessor = redundant_sort?(node.parent&.parent))
+            return if use_size_method_in_block?(sort_node)
+
             ancestor = node.parent.parent
           else
             return
           end
 
+          register_offense(ancestor, sort_node, sorter, accessor)
+        end
+
+        private
+
+        def use_size_method_in_block?(sort_node)
+          return true if sort_node.send_type? && sort_node.block_node&.body&.method?(:size)
+          return false unless sort_node.block_argument?
+
+          sort_node.last_argument.children.first.value == :size
+        end
+
+        def register_offense(ancestor, sort_node, sorter, accessor)
           message = message(ancestor, sorter, accessor)
 
           add_offense(offense_range(sort_node, ancestor), message: message) do |corrector|
@@ -90,8 +107,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(corrector, node, sort_node, sorter, accessor)
           # Remove accessor, e.g. `first` or `[-1]`.
           corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))

data/lib/rubocop/cop/style/regexp_literal.rb

@@ -107,7 +107,7 @@ module RuboCop
         private
 
         def allowed_slash_literal?(node)
-          style == :slashes && !contains_disallowed_slash?(node) || allowed_mixed_slash?(node)
+          (style == :slashes && !contains_disallowed_slash?(node)) || allowed_mixed_slash?(node)
         end
 
         def allowed_mixed_slash?(node)
@@ -115,13 +115,13 @@ module RuboCop
         end
 
         def allowed_percent_r_literal?(node)
-          style == :slashes && contains_disallowed_slash?(node) ||
+          (style == :slashes && contains_disallowed_slash?(node)) ||
             style == :percent_r ||
             allowed_mixed_percent_r?(node) || allowed_omit_parentheses_with_percent_r_literal?(node)
         end
 
         def allowed_mixed_percent_r?(node)
-          style == :mixed && node.multiline? || contains_disallowed_slash?(node)
+          (style == :mixed && node.multiline?) || contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)

data/lib/rubocop/cop/style/return_nil.rb

@@ -74,7 +74,8 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :return && !return_nil_node?(node) || style == :return_nil && !return_node?(node)
+          (style == :return && !return_nil_node?(node)) ||
+            (style == :return_nil && !return_node?(node))
         end
 
         def scoped_node?(node)

data/lib/rubocop/cop/style/static_class.rb

@@ -60,8 +60,7 @@ module RuboCop
           return false if nodes.empty?
 
           nodes.all? do |node|
-            node_visibility(node) == :public &&
-              node.defs_type? ||
+            (node_visibility(node) == :public && node.defs_type?) ||
               sclass_convertible_to_module?(node) ||
               node.equals_asgn? ||
               extend_call?(node)

data/lib/rubocop/cop/style/string_concatenation.rb

@@ -93,7 +93,7 @@ module RuboCop
 
         def offensive_for_mode?(receiver_node)
           mode = cop_config['Mode'].to_sym
-          mode == :aggressive || mode == :conservative && receiver_node.str_type?
+          mode == :aggressive || (mode == :conservative && receiver_node.str_type?)
         end
 
         def line_end_concatenation?(node)

data/lib/rubocop/cop/style/trivial_accessors.rb

@@ -192,7 +192,7 @@ module RuboCop
 
         def allowed_method_name?(node)
           allowed_method_names.include?(node.method_name) ||
-            exact_name_match? && !names_match?(node)
+            (exact_name_match? && !names_match?(node))
         end
 
         def allowed_writer?(method_name)

data/lib/rubocop/cop/style/yoda_condition.rb

@@ -58,14 +58,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
         REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
-
         EQUALITY_OPERATORS = %i[== !=].freeze
-
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -74,7 +71,7 @@ module RuboCop
 
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node) ||
+          return if (equality_only? && non_equality_operator?(node)) ||
                     file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node) do |corrector|
@@ -102,8 +99,8 @@ module RuboCop
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal? ||
+          return true if (lhs.literal? && rhs.literal?) ||
+                         (!lhs.literal? && !rhs.literal?) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?

data/lib/rubocop/result_cache.rb

@@ -45,7 +45,7 @@ module RuboCop
       def remove_oldest_files(files, dirs, cache_root, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
-        remove_count = 1 + files.length / 2
+        remove_count = 1 + (files.length / 2)
         puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)

data/lib/rubocop/runner.rb

@@ -216,8 +216,7 @@ module RuboCop
     def cached_run?
       @cached_run ||=
         (@options[:cache] == 'true' ||
-         @options[:cache] != 'false' &&
-         @config_store.for_pwd.for_all_cops['UseCache']) &&
+         (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) &&
         # When running --auto-gen-config, there's some processing done in the
         # cops related to calculating the Max parameters for Metrics cops. We
         # need to do that processing and cannot use caching.