rubocop 0.77.0 → 0.81.0

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style omit_parentheses
+        module OmitParentheses
+          TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+
+          def on_send(node)
+            return unless node.parenthesized?
+            return if node.implicit_call?
+            return if super_call_without_arguments?(node)
+            return if allowed_camel_case_method_call?(node)
+            return if legitimate_call_with_parentheses?(node)
+
+            add_offense(node, location: node.loc.begin.join(node.loc.end))
+          end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          def autocorrect(node)
+            lambda do |corrector|
+              if parentheses_at_the_end_of_multiline_call?(node)
+                corrector.replace(args_begin(node), ' \\')
+              else
+                corrector.replace(args_begin(node), ' ')
+              end
+              corrector.remove(node.loc.end)
+            end
+          end
+
+          def message(_node = nil)
+            'Omit parentheses for method calls with arguments.'
+          end
+
+          private
+
+          def super_call_without_arguments?(node)
+            node.super_type? && node.arguments.none?
+          end
+
+          def allowed_camel_case_method_call?(node)
+            node.camel_case_method? &&
+              (node.arguments.none? ||
+              cop_config['AllowParenthesesInCamelCaseMethod'])
+          end
+
+          def parentheses_at_the_end_of_multiline_call?(node)
+            node.multiline? &&
+              node.loc.begin.source_line
+                  .gsub(TRAILING_WHITESPACE_REGEX, '')
+                  .end_with?('(')
+          end
+
+          def legitimate_call_with_parentheses?(node)
+            call_in_literals?(node) ||
+              call_with_ambiguous_arguments?(node) ||
+              call_in_logical_operators?(node) ||
+              call_in_optional_arguments?(node) ||
+              allowed_multiline_call_with_parentheses?(node) ||
+              allowed_chained_call_with_parentheses?(node)
+          end
+
+          def call_in_literals?(node)
+            node.parent &&
+              (node.parent.pair_type? ||
+              node.parent.array_type? ||
+              node.parent.range_type? ||
+              splat?(node.parent) ||
+              ternary_if?(node.parent))
+          end
+
+          def call_in_logical_operators?(node)
+            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent &&
+              (logical_operator?(parent) ||
+              parent.send_type? &&
+              parent.arguments.any?(&method(:logical_operator?)))
+          end
+
+          def call_in_optional_arguments?(node)
+            node.parent &&
+              (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+          end
+
+          def call_with_ambiguous_arguments?(node)
+            call_with_braced_block?(node) ||
+              call_as_argument_or_chain?(node) ||
+              hash_literal_in_arguments?(node) ||
+              node.descendants.any? do |n|
+                ambigious_literal?(n) || logical_operator?(n) ||
+                  call_with_braced_block?(n)
+              end
+          end
+
+          def call_with_braced_block?(node)
+            (node.send_type? || node.super_type?) &&
+              node.block_node && node.block_node.braces?
+          end
+
+          def call_as_argument_or_chain?(node)
+            node.parent &&
+              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
+              node.parent.csend_type? || node.parent.super_type?)
+          end
+
+          def hash_literal_in_arguments?(node)
+            node.arguments.any? do |n|
+              hash_literal?(n) ||
+                n.send_type? && node.descendants.any?(&method(:hash_literal?))
+            end
+          end
+
+          def allowed_multiline_call_with_parentheses?(node)
+            cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
+          end
+
+          def allowed_chained_call_with_parentheses?(node)
+            return false unless cop_config['AllowParenthesesInChaining']
+
+            previous = node.descendants.first
+            return false unless previous&.send_type?
+
+            previous.parenthesized? ||
+              allowed_chained_call_with_parentheses?(previous)
+          end
+
+          def ambigious_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
+              unary_literal?(node)
+          end
+
+          def splat?(node)
+            node.splat_type? || node.kwsplat_type? || node.block_pass_type?
+          end
+
+          def ternary_if?(node)
+            node.if_type? && node.ternary?
+          end
+
+          def logical_operator?(node)
+            (node.and_type? || node.or_type?) && node.logical_operator?
+          end
+
+          def hash_literal?(node)
+            node.hash_type? && node.braces?
+          end
+
+          def regexp_slash_literal?(node)
+            node.regexp_type? && node.loc.begin.source == '/'
+          end
+
+          def unary_literal?(node)
+            node.numeric_type? && node.sign? ||
+              node.parent&.send_type? && node.parent&.unary_operation?
+          end
+
+          def assigned_before?(node, target)
+            node.assignment? &&
+              node.loc.operator.begin < target.loc.begin
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self.
+      # Supported styles are: module_function, extend_self, forbidden.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -46,6 +46,29 @@ module RuboCop
       #     # ...
       #   end
       #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
+      #
       # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
       class ModuleFunction < Cop
@@ -55,6 +78,8 @@ module RuboCop
           'Use `module_function` instead of `extend self`.'
         EXTEND_SELF_MSG =
           'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG =
+          'Do not use `module_function` or `extend self`.'
 
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
@@ -69,6 +94,8 @@ module RuboCop
         end
 
         def autocorrect(node)
+          return if style == :forbidden
+
           lambda do |corrector|
             if extend_self_node?(node)
               corrector.replace(node.source_range, 'module_function')
@@ -80,22 +107,41 @@ module RuboCop
 
         private
 
-        def each_wrong_style(nodes)
+        def each_wrong_style(nodes, &block)
           case style
           when :module_function
-            private_directive = nodes.any? { |node| private_directive?(node) }
-
-            nodes.each do |node|
-              yield node if extend_self_node?(node) && !private_directive
-            end
+            check_module_function(nodes, &block)
           when :extend_self
-            nodes.each do |node|
-              yield node if module_function_node?(node)
-            end
+            check_extend_self(nodes, &block)
+          when :forbidden
+            check_forbidden(nodes, &block)
+          end
+        end
+
+        def check_module_function(nodes)
+          private_directive = nodes.any? { |node| private_directive?(node) }
+
+          nodes.each do |node|
+            yield node if extend_self_node?(node) && !private_directive
+          end
+        end
+
+        def check_extend_self(nodes)
+          nodes.each do |node|
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def check_forbidden(nodes)
+          nodes.each do |node|
+            yield node if extend_self_node?(node)
+            yield node if module_function_node?(node)
           end
         end
 
         def message(_node)
+          return FORBIDDEN_MSG if style == :forbidden
+
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
         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
@@ -49,6 +49,10 @@ module RuboCop
             )
           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_parenthesized_calls.rb

@@ -8,10 +8,10 @@ module RuboCop
       #
       # @example
       #   # good
-      #   method1(method2(arg), method3(arg))
+      #   method1(method2(arg))
       #
       #   # bad
-      #   method1(method2 arg, method3, arg)
+      #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
         include RangeHelp
 
@@ -35,8 +35,8 @@ module RuboCop
           last_arg = nested.last_argument.source_range
 
           leading_space =
-            range_with_surrounding_space(range: first_arg,
-                                         side: :left).begin.resize(1)
+            range_with_surrounding_space(range: first_arg.begin,
+                                         side: :left)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')

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

@@ -91,9 +91,10 @@ module RuboCop
 
         def keyword_with_changed_precedence?(node)
           return false unless node.keyword?
-          return true if node.prefix_not?
+          return true if node.respond_to?(:prefix_not?) && node.prefix_not?
 
-          node.arguments? && !node.parenthesized_call?
+          node.respond_to?(:arguments?) && node.arguments? &&
+            !node.parenthesized_call?
         end
       end
     end

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