rubocop 0.75.1 → 0.80.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style require_parentheses
+        module RequireParentheses
+          def on_send(node)
+            return if ignored_method?(node.method_name)
+            return if matches_ignored_pattern?(node.method_name)
+            return if eligible_for_parentheses_omission?(node)
+            return unless node.arguments? && !node.parenthesized?
+
+            add_offense(node)
+          end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          def autocorrect(node)
+            lambda do |corrector|
+              corrector.replace(args_begin(node), '(')
+
+              unless args_parenthesized?(node)
+                corrector.insert_after(args_end(node), ')')
+              end
+            end
+          end
+
+          def message(_node = nil)
+            'Use parentheses for method calls with arguments.'
+          end
+
+          private
+
+          def eligible_for_parentheses_omission?(node)
+            node.operator_method? || node.setter_method? || ignored_macro?(node)
+          end
+
+          def included_macros_list
+            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+          end
+
+          def ignored_macro?(node)
+            cop_config['IgnoreMacros'] &&
+              node.macro? &&
+              !included_macros_list.include?(node.method_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -113,22 +113,30 @@ module RuboCop
           lambda do |corrector|
             if node.args_type?
               # offense is registered on args node when parentheses are unwanted
-              corrector.replace(node.loc.begin, ' ')
-              corrector.remove(node.loc.end)
+              correct_arguments(node, corrector)
             else
-              args_expr = node.arguments.source_range
-              args_with_space = range_with_surrounding_space(range: args_expr,
-                                                             side: :left)
-              just_space = range_between(args_with_space.begin_pos,
-                                         args_expr.begin_pos)
-              corrector.replace(just_space, '(')
-              corrector.insert_after(args_expr, ')')
+              correct_definition(node, corrector)
             end
           end
         end
 
         private
 
+        def correct_arguments(arg_node, corrector)
+          corrector.replace(arg_node.loc.begin, ' ')
+          corrector.remove(arg_node.loc.end)
+        end
+
+        def correct_definition(def_node, corrector)
+          arguments_range = def_node.arguments.source_range
+          args_with_space = range_with_surrounding_space(range: arguments_range,
+                                                         side: :left)
+          leading_space = range_between(args_with_space.begin_pos,
+                                        arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline &&

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

@@ -103,7 +103,7 @@ module RuboCop
                               .select(&:macro?)
 
           siblings.select do |sibling_node|
-            sibling_node.method_name == send_node.method_name
+            sibling_node.method?(send_node.method_name)
           end
         end
 

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

@@ -53,7 +53,7 @@ module RuboCop
         end
 
         def max_line_length
-          config.for_cop('Metrics/LineLength')['Max'] || 80
+          config.for_cop('Layout/LineLength')['Max'] || 80
         end
       end
     end

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

@@ -35,7 +35,7 @@ module RuboCop
           return if !node.children.last.nil? && !node.multiline? && node.then?
 
           # With more than one statements after then, there's not offense
-          return if node.children.last&.begin_type?
+          return if accept_node_type?(node.body)
 
           add_offense(node, location: :begin)
         end
@@ -44,11 +44,15 @@ module RuboCop
           lambda do |corrector|
             corrector.remove(
               range_with_surrounding_space(
-                range: node.loc.begin, side: :left
+                range: node.loc.begin, side: :left, newlines: false
               )
             )
           end
         end
+
+        def accept_node_type?(node)
+          node&.begin_type? || node&.array_type? || node&.hash_type?
+        end
       end
     end
   end

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

@@ -49,11 +49,13 @@ module RuboCop
                                 node.parent.condition.source_range.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, new_expression(node.parent, node))
+            corrector.replace(range, new_expression(node))
           end
         end
 
-        def new_expression(outer_node, inner_node)
+        def new_expression(inner_node)
+          outer_node = inner_node.parent
+
           operator = replacement_operator(outer_node.keyword)
           lh_operand = left_hand_operand(outer_node, operator)
           rh_operand = right_hand_operand(inner_node, outer_node.keyword)

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

@@ -49,17 +49,17 @@ module RuboCop
         def allowed_omission?(send_node)
           !send_node.arguments? || send_node.parenthesized? ||
             send_node.setter_method? || send_node.operator_method? ||
-            whitelisted?(send_node)
+            allowed?(send_node)
         end
 
-        def whitelisted?(send_node)
+        def allowed?(send_node)
           send_node.parent.arguments.one? &&
-            whitelisted_methods.include?(send_node.method_name.to_s) &&
+            allowed_methods.include?(send_node.method_name.to_s) &&
             send_node.arguments.one?
         end
 
-        def whitelisted_methods
-          cop_config['Whitelist'] || []
+        def allowed_methods
+          cop_config['AllowedMethods'] || []
         end
       end
     end

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

@@ -20,18 +20,18 @@ module RuboCop
       #   end
       #
       #   # good
-      #   [1, 2].each do |o|
-      #     puts o unless o == 1
+      #   [1, 2].each do |a|
+      #     puts a if a == 1
       #   end
       #
       # @example EnforcedStyle: always
       #   # With `always` all conditions at the end of an iteration needs to be
       #   # replaced by next - with `skip_modifier_ifs` the modifier if like
-      #   # this one are ignored: `[1, 2].each { |a| return 'yes' if a == 1 }`
+      #   # this one are ignored: `[1, 2].each { |a| puts a if a == 1 }`
       #
       #   # bad
-      #   [1, 2].each do |o|
-      #     puts o unless o == 1
+      #   [1, 2].each do |a|
+      #     puts a if a == 1
       #   end
       #
       #   # bad

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

@@ -5,27 +5,39 @@ module RuboCop
     module Style
       # This cop checks for non-nil checks, which are usually redundant.
       #
-      # @example
+      # With `IncludeSemanticChanges` set to `false` by default, this cop
+      # does not report offenses for `!x.nil?` and does no changes that might
+      # change behavior.
+      #
+      # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
+      # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
+      # is **usually** OK, but might change behavior.
       #
+      # @example
       #   # bad
       #   if x != nil
       #   end
       #
-      #   # good (when not allowing semantic changes)
-      #   # bad (when allowing semantic changes)
-      #   if !x.nil?
-      #   end
-      #
-      #   # good (when allowing semantic changes)
+      #   # good
       #   if x
       #   end
       #
-      # Non-nil checks are allowed if they are the final nodes of predicate.
-      #
+      #   # Non-nil checks are allowed if they are the final nodes of predicate.
       #   # good
       #   def signed_in?
       #     !current_user.nil?
       #   end
+      #
+      # @example IncludeSemanticChanges: false (default)
+      #   # good
+      #   if !x.nil?
+      #   end
+      #
+      # @example IncludeSemanticChanges: true
+      #   # bad
+      #   if !x.nil?
+      #   end
+      #
       class NonNilCheck < Cop
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'

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

@@ -9,18 +9,22 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   1000000
       #   1_00_000
       #   1_0000
       #
       #   # good
-      #
       #   1_000_000
       #   1000
       #
-      #   # good unless Strict is set
+      # @example Strict: false (default)
       #
+      #   # good
+      #   10_000_00 # typical representation of $10,000 in cents
+      #
+      # @example Strict: true
+      #
+      #   # bad
       #   10_000_00 # typical representation of $10,000 in cents
       #
       class NumericLiterals < Cop

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

@@ -54,9 +54,10 @@ module RuboCop
         }.freeze
 
         def on_send(node)
-          return if node.each_ancestor(:send, :block).any? do |ancestor|
-            ignored_method?(ancestor.method_name)
-          end
+          return if ignored_method?(node.method_name) ||
+                    node.each_ancestor(:send, :block).any? do |ancestor|
+                      ignored_method?(ancestor.method_name)
+                    end
 
           numeric, replacement = check(node)
 

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

@@ -28,7 +28,7 @@ module RuboCop
 
         def on_args(node)
           return if super_used?(node)
-          return if whitelist.include?(node.parent.method_name.to_s)
+          return if allowlist.include?(node.parent.method_name.to_s)
 
           option_hash(node) do |options|
             add_offense(options)
@@ -37,8 +37,8 @@ module RuboCop
 
         private
 
-        def whitelist
-          cop_config['Whitelist'] || []
+        def allowlist
+          cop_config['Allowlist'] || []
         end
 
         def suspicious_name?(arg_name)

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

@@ -34,7 +34,7 @@ module RuboCop
             (if
               ({lvar ivar cvar gvar} _var)
               ({lvar ivar cvar gvar} _var)
-              _))
+              $_))
         PATTERN
 
         def_node_matcher :unless_assignment?, <<~PATTERN
@@ -51,7 +51,8 @@ module RuboCop
         end
 
         def on_lvasgn(node)
-          return unless ternary_assignment?(node)
+          return unless (else_branch = ternary_assignment?(node))
+          return if else_branch.if_type?
 
           add_offense(node)
         end

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

@@ -88,27 +88,27 @@ module RuboCop
         end
 
         def contains_preferred_delimiter?(node, type)
-          preferred_delimiters = preferred_delimiters_for(type)
-          node
-            .children.map { |n| string_source(n) }.compact
-            .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
+          contains_delimiter?(node, preferred_delimiters_for(type))
         end
 
         def include_same_character_as_used_for_delimiter?(node, type)
           return false unless %w[%w %i].include?(type)
 
           used_delimiters = matchpairs(begin_source(node)[-1])
-          escaped_delimiters = used_delimiters.map { |d| "\\#{d}" }.join('|')
+          contains_delimiter?(node, used_delimiters)
+        end
 
+        def contains_delimiter?(node, delimiters)
+          delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| Regexp.new(escaped_delimiters) =~ s }
+            .any? { |s| delimiters_regexp =~ s }
         end
 
         def string_source(node)
           if node.is_a?(String)
             node
-          elsif node.respond_to?(:type) && node.str_type?
+          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
             node.source
           end
         end

data/lib/rubocop/cop/style/{unneeded_capital_w.rb → redundant_capital_w.rb}

@@ -14,7 +14,7 @@ module RuboCop
       #   %w/swim run bike/
       #   %w[shirt pants shoes]
       #   %W(apple #{fruit} grape)
-      class UnneededCapitalW < Cop
+      class RedundantCapitalW < Cop
         include PercentLiteral
 
         MSG = 'Do not use `%W` unless interpolation is needed. ' \

data/lib/rubocop/cop/style/{unneeded_condition.rb → redundant_condition.rb}

@@ -30,11 +30,11 @@ module RuboCop
       #     c
       #   end
       #
-      class UnneededCondition < Cop
+      class RedundantCondition < Cop
         include RangeHelp
 
         MSG = 'Use double pipes `||` instead.'
-        UNNEEDED_CONDITION = 'This condition is not needed.'
+        REDUNDANT_CONDITION = 'This condition is not needed.'
 
         def on_if(node)
           return if node.elsif_conditional?
@@ -61,7 +61,7 @@ module RuboCop
 
         def message(node)
           if node.modifier_form? || !node.else_branch
-            UNNEEDED_CONDITION
+            REDUNDANT_CONDITION
           else
             MSG
           end

data/lib/rubocop/cop/style/{unneeded_interpolation.rb → redundant_interpolation.rb}

@@ -15,7 +15,7 @@ module RuboCop
       #
       #   # good if @var is already a String
       #   @var
-      class UnneededInterpolation < Cop
+      class RedundantInterpolation < Cop
         include PercentLiteral
 
         MSG = 'Prefer `to_s` over string interpolation.'

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

@@ -19,7 +19,7 @@ module RuboCop
         def_node_matcher :square_brackets?,
                          '(send {(send _recv _msg) str array hash} :[] ...)'
         def_node_matcher :range_end?, '^^{irange erange}'
-        def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
+        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
         def_node_matcher :arg_in_call_with_block?,
                          '^^(block (send _ _ equal?(%0) ...) ...)'
@@ -102,7 +102,7 @@ module RuboCop
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
 
-          check_send(begin_node, node) if node.send_type?
+          check_send(begin_node, node) if node.call_type?
         end
 
         def check_send(begin_node, node)
@@ -195,7 +195,7 @@ module RuboCop
         end
 
         def method_call_with_redundant_parentheses?(node)
-          return false unless node.send_type?
+          return false unless node.call_type?
           return false if node.prefix_not?
           return false if range_end?(node)
 

data/lib/rubocop/cop/style/{unneeded_percent_q.rb → redundant_percent_q.rb}

@@ -17,7 +17,7 @@ module RuboCop
       #   time = "8 o'clock"
       #   question = '"What did you say?"'
       #
-      class UnneededPercentQ < Cop
+      class RedundantPercentQ < Cop
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \