rubocop 0.76.0 → 0.79.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of "*" as a substitute for *join*.
+      # This cop checks for uses of "\*" as a substitute for *join*.
       #
       # Not all cases can reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an

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

@@ -21,6 +21,10 @@ module RuboCop
 
         def on_send(node)
           return unless node.command?(:attr) && node.arguments?
+          # check only for method definitions in class/module body
+          return if node.parent &&
+                    !node.parent.class_type? &&
+                    !class_eval?(node.parent)
 
           add_offense(node, location: :selector)
         end
@@ -56,6 +60,10 @@ module RuboCop
             'attr_reader'
           end
         end
+
+        def_node_matcher :class_eval?, <<~PATTERN
+          (block (send _ {:class_eval :module_eval}) ...)
+        PATTERN
       end
     end
   end

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

@@ -212,7 +212,7 @@ module RuboCop
           %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
                            %i[and_asgn or_asgn op_asgn masgn].freeze
-        LINE_LENGTH = 'Metrics/LineLength'
+        LINE_LENGTH = 'Layout/LineLength'
         INDENTATION_WIDTH = 'Layout/IndentationWidth'
         ENABLED = 'Enabled'
         MAX = 'Max'
@@ -376,7 +376,7 @@ module RuboCop
             assignment_types_match?(*statements)
         end
 
-        # If `Metrics/LineLength` is enabled, we do not want to introduce an
+        # If `Layout/LineLength` is enabled, we do not want to introduce an
         # offense by auto-correcting this cop. Find the max configured line
         # length. Find the longest line of condition. Remove the assignment
         # from lines that contain the offending assignment because after

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

@@ -85,7 +85,7 @@ module RuboCop
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
-          if node.method_name == :eval
+          if node.method?(:eval)
             node.arguments.size == 4
           else
             node.arguments.size == 3

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

@@ -23,7 +23,7 @@ module RuboCop
             {(send $_ :% (int 2))
              (begin (send $_ :% (int 2)))}
             ${:== :!=}
-            (int ${0 1 2}))
+            (int ${0 1}))
         PATTERN
 
         def on_send(node)

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

@@ -49,8 +49,9 @@ module RuboCop
 
           if body.if_type?
             check_ending_if(body)
-          elsif body.begin_type? && body.children.last.if_type?
-            check_ending_if(body.children.last)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
           end
         end
         alias on_defs on_def

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

@@ -7,7 +7,7 @@ module RuboCop
       # written as modifier `if`/`unless`. The cop also checks for modifier
       # `if`/`unless` lines that exceed the maximum line length.
       #
-      # The maximum line length is configured in the `Metrics/LineLength`
+      # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/Tab` cop.
       #
@@ -32,6 +32,8 @@ module RuboCop
       #   end
       class IfUnlessModifier < Cop
         include StatementModifier
+        include LineLengthHelp
+        include IgnoredPattern
 
         MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
                            'single-line body. Another good alternative is ' \
@@ -66,6 +68,10 @@ module RuboCop
 
         private
 
+        def ignored_patterns
+          config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
+        end
+
         def too_long_single_line?(node)
           return false unless max_line_length
 
@@ -73,12 +79,41 @@ module RuboCop
           return false unless range.first_line == range.last_line
           return false unless line_length_enabled_at_line?(range.first_line)
 
-          range.last_column > max_line_length
+          line = range.source_line
+          return false if line_length(line) <= max_line_length
+
+          too_long_line_based_on_config?(range, line)
+        end
+
+        def too_long_line_based_on_config?(range, line)
+          return false if matches_ignored_pattern?(line)
+
+          too_long = too_long_line_based_on_ignore_cop_directives?(range, line)
+          return too_long unless too_long == :undetermined
+
+          too_long_line_based_on_allow_uri?(line)
+        end
+
+        def too_long_line_based_on_ignore_cop_directives?(range, line)
+          if ignore_cop_directives? && directive_on_source_line?(range.line - 1)
+            return line_length_without_directive(line) > max_line_length
+          end
+
+          :undetermined
+        end
+
+        def too_long_line_based_on_allow_uri?(line)
+          if allow_uri?
+            uri_range = find_excessive_uri_range(line)
+            return false if uri_range && allowed_uri_position?(line, uri_range)
+          end
+
+          true
         end
 
         def line_length_enabled_at_line?(line)
           processed_source.comment_config
-                          .cop_enabled_at_line?('Metrics/LineLength', line)
+                          .cop_enabled_at_line?('Layout/LineLength', line)
         end
 
         def named_capture_in_condition?(node)

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

@@ -58,7 +58,7 @@ module RuboCop
           # `loop do` without further modification. The reason is that a
           # variable that's introduced inside a while/until loop is in scope
           # outside of that loop too, but a variable that's assigned for the
-          # first time inside a block can not be accessed after the block. In
+          # first time inside a block cannot be accessed after the block. In
           # those more complicated cases we don't report an offense.
           return if @variables.any? do |var|
             assigned_inside_loop?(var, range) &&

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

@@ -28,7 +28,7 @@ module RuboCop
           contents = node.source[1...-1]
           return false if contents.empty?
 
-          return false if whitelist.include?(contents.downcase)
+          return false if allowed_addresses.include?(contents.downcase)
 
           # To try to avoid doing two regex checks on every string,
           # shortcut out if the string does not look like an IP address
@@ -47,9 +47,9 @@ module RuboCop
 
         private
 
-        def whitelist
-          whitelist = cop_config['Whitelist']
-          Array(whitelist).map(&:downcase)
+        def allowed_addresses
+          allowed_addresses = cop_config['AllowedAddresses']
+          Array(allowed_addresses).map(&:downcase)
         end
 
         def could_be_ip?(str)

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

@@ -0,0 +1,168 @@
+# 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)
+            node.parent &&
+              (logical_operator?(node.parent) ||
+              node.parent.send_type? &&
+              node.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/method_call_with_args_parentheses.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -43,7 +42,6 @@ module RuboCop
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
-      #
       #   # bad
       #   array.delete e
       #
@@ -150,94 +148,18 @@ module RuboCop
         include IgnoredMethods
         include IgnoredPattern
 
-        TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
-
-        def on_send(node)
-          case style
-          when :require_parentheses
-            add_offense_for_require_parentheses(node)
-          when :omit_parentheses
-            add_offense_for_omit_parentheses(node)
-          end
-        end
-        alias on_csend on_send
-        alias on_super on_send
-        alias on_yield on_send
-
-        def autocorrect(node)
-          case style
-          when :require_parentheses
-            autocorrect_for_require_parentheses(node)
-          when :omit_parentheses
-            autocorrect_for_omit_parentheses(node)
-          end
-        end
-
-        def message(_node = nil)
+        def initialize(*)
+          super
           case style
           when :require_parentheses
-            'Use parentheses for method calls with arguments.'
+            extend RequireParentheses
           when :omit_parentheses
-            'Omit parentheses for method calls with arguments.'
+            extend OmitParentheses
           end
         end
 
         private
 
-        def add_offense_for_require_parentheses(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
-
-        def add_offense_for_omit_parentheses(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
-
-        def autocorrect_for_require_parentheses(node)
-          lambda do |corrector|
-            corrector.replace(args_begin(node), '(')
-
-            unless args_parenthesized?(node)
-              corrector.insert_after(args_end(node), ')')
-            end
-          end
-        end
-
-        def autocorrect_for_omit_parentheses(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 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
-
         def args_begin(node)
           loc = node.loc
           selector =
@@ -257,132 +179,7 @@ module RuboCop
           first_node = node.arguments.first
           first_node.begin_type? && first_node.parenthesized_call?
         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 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 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)
-          node.parent &&
-            (logical_operator?(node.parent) ||
-             node.parent.send_type? &&
-             node.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
-# rubocop:enable Metrics/ClassLength

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