rubocop 0.75.1 → 0.78.0

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

@@ -155,7 +155,7 @@ module RuboCop
             return true if node.literal?
             return false unless node.send_type?
 
-            node.method_name == :new
+            node.method?(:new)
           end
         end
       end

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

@@ -55,10 +55,10 @@ module RuboCop
         VOID_CONTEXT_TYPES = %i[def for block].freeze
         NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
                                  delete_prefix delete_suffix downcase
-                                 encode flatten gsub lstrip map next reject
-                                 reverse rotate rstrip scrub select shuffle
-                                 slice sort sort_by squeeze strip sub succ
-                                 swapcase tr tr_s transform_values
+                                 encode flatten gsub lstrip map merge next
+                                 reject reverse rotate rstrip scrub select
+                                 shuffle slice sort sort_by squeeze strip sub
+                                 succ swapcase tr tr_s transform_values
                                  unicode_normalize uniq upcase].freeze
 
         def on_block(node)

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -11,7 +11,7 @@ module RuboCop
         include MethodComplexity
 
         MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
-              '[%<complexity>.4g/%<max>.4g]'
+              '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
 
         private
 

data/lib/rubocop/cop/metrics/method_length.rb

@@ -20,7 +20,7 @@ module RuboCop
         alias on_defs on_def
 
         def on_block(node)
-          return unless node.send_node.method_name == :define_method
+          return unless node.send_node.method?(:define_method)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -36,15 +36,17 @@ module RuboCop
             @node.each_node do |child|
               if child.assignment?
                 @assignment += 1
-              elsif BRANCH_NODES.include?(child.type)
+              elsif branch?(child)
                 evaluate_branch_nodes(child)
-              elsif CONDITION_NODES.include?(child.type)
-                @condition += 1 if node_has_else_branch?(child)
-                @condition += 1
+              elsif condition?(child)
+                evaluate_condition_node(child)
               end
             end
 
-            Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2)
+            [
+              Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2),
+              "<#{@assignment}, #{@branch}, #{@condition}>"
+            ]
           end
 
           def evaluate_branch_nodes(node)
@@ -55,11 +57,26 @@ module RuboCop
             end
           end
 
-          def node_has_else_branch?(node)
+          def evaluate_condition_node(node)
+            @condition += 1 if else_branch?(node)
+            @condition += 1
+          end
+
+          def else_branch?(node)
             %i[case if].include?(node.type) &&
               node.else? &&
               node.loc.else.is?('else')
           end
+
+          private
+
+          def branch?(node)
+            BRANCH_NODES.include?(node.type)
+          end
+
+          def condition?(node)
+            CONDITION_NODES.include?(node.type)
+          end
         end
       end
     end

data/lib/rubocop/cop/mixin/alignment.rb

@@ -35,7 +35,7 @@ module RuboCop
             # If this offense is within a line range that is already being
             # realigned by autocorrect, we report the offense without
             # autocorrecting it. Two rewrites in the same area by the same
-            # cop can not be handled. The next iteration will find the
+            # cop cannot be handled. The next iteration will find the
             # offense again and correct it.
             add_offense(nil, location: expr)
           else

data/lib/rubocop/cop/mixin/{hash_alignment.rb → hash_alignment_styles.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     # Common functionality for checking hash alignment.
-    module HashAlignment
+    module HashAlignmentStyles
       # Handles calculation of deltas when the enforced style is 'key'.
       class KeyAlignment
         def checkable_layout?(_node)

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      end
+
+      def directive_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment =
+          processed_source.comments
+                          .detect { |e| e.location.line == source_line_number }
+
+        return false unless comment
+
+        comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+      end
+
+      def allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length &&
+          (uri_range.end == line_length(line) ||
+           uri_range.end == line_length(line) - 1)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      end
+
+      def find_excessive_uri_range(line)
+        last_uri_match = match_uris(line).last
+        return nil unless last_uri_match
+
+        begin_position, end_position = last_uri_match.offset(0).map do |pos|
+          pos + indentation_difference(line)
+        end
+        return nil if begin_position < max_line_length &&
+                      end_position < max_line_length
+
+        begin_position...end_position
+      end
+
+      def match_uris(string)
+        matches = []
+        string.scan(uri_regexp) do
+          matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
+        end
+        matches
+      end
+
+      def indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/Tab')['IndentationWidth']
+      end
+
+      def uri_regexp
+        @uri_regexp ||=
+          URI::DEFAULT_PARSER
+          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        before_comment.rstrip.length
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -32,13 +32,14 @@ module RuboCop
         return unless node.body
 
         max = cop_config['Max']
-        complexity = complexity(node.body)
+        complexity, abc_vector = complexity(node.body)
 
         return unless complexity > max
 
         msg = format(self.class::MSG,
                      method: method_name,
                      complexity: complexity,
+                     abc_vector: abc_vector,
                      max: max)
 
         add_offense(node, message: msg) do

data/lib/rubocop/cop/mixin/nil_methods.rb

@@ -5,20 +5,20 @@ module RuboCop
     # This module provides a list of methods that are:
     # 1. In the NilClass by default
     # 2. Added to NilClass by explicitly requiring any standard libraries
-    # 3. Cop's configuration parameter Whitelist.
+    # 3. Cop's configuration parameter AllowedMethods.
     module NilMethods
       private
 
       def nil_methods
-        nil.methods + other_stdlib_methods + whitelist
+        nil.methods + other_stdlib_methods + allowed_methods
       end
 
       def other_stdlib_methods
         [:to_d]
       end
 
-      def whitelist
-        cop_config['Whitelist'].map(&:to_sym)
+      def allowed_methods
+        cop_config['AllowedMethods'].map(&:to_sym)
       end
     end
   end

data/lib/rubocop/cop/mixin/rational_literal.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Rational literals.
+    module RationalLiteral
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :rational_literal?, <<~PATTERN
+        (send
+          (int _) :/
+          (rational _))
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -41,17 +41,20 @@ module RuboCop
       end
 
       def length_in_modifier_form(node, cond, body_length)
-        indentation = node.loc.keyword.column * indentation_multiplier
-        kw_length = node.loc.keyword.size
+        keyword = node.loc.keyword
+
+        indentation = keyword.column * indentation_multiplier
+        kw_length = keyword.size
         cond_length = cond.source_range.size
         space = 1
+
         indentation + body_length + space + kw_length + space + cond_length
       end
 
       def max_line_length
-        return unless config.for_cop('Metrics/LineLength')['Enabled']
+        return unless config.for_cop('Layout/LineLength')['Enabled']
 
-        config.for_cop('Metrics/LineLength')['Max']
+        config.for_cop('Layout/LineLength')['Max']
       end
 
       def indentation_multiplier

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -18,12 +18,7 @@ module RuboCop
 
       def check(node, items, kind, begin_pos, end_pos)
         after_last_item = range_between(begin_pos, end_pos)
-
-        # If there is any heredoc in items, then match the comma succeeding
-        # any whitespace (except newlines), otherwise allow for newlines
-        comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
-        comma_offset = after_last_item.source =~ comma_regex &&
-                       after_last_item.source.index(',')
+        comma_offset = comma_offset(items, after_last_item)
 
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
@@ -32,6 +27,13 @@ module RuboCop
         end
       end
 
+      def comma_offset(items, range)
+        # If there is any heredoc in items, then match the comma succeeding
+        # any whitespace (except newlines), otherwise allow for newlines
+        comma_regex = any_heredoc?(items) ? /\A[^\S\n]*,/ : /\A\s*,/
+        range.source =~ comma_regex && range.source.index(',')
+      end
+
       def check_comma(node, kind, comma_pos)
         return if should_have_comma?(style, node)
 
@@ -91,9 +93,12 @@ module RuboCop
       end
 
       def method_name_and_arguments_on_same_line?(node)
-        %i[send csend].include?(node.type) &&
-          node.loc.selector.line == node.arguments.last.last_line &&
-          node.last_line == node.arguments.last.last_line
+        return false unless node.call_type?
+
+        line = node.loc.selector.nil? ? node.loc.line : node.loc.selector.line
+
+        line == node.last_argument.last_line &&
+          node.last_line == node.last_argument.last_line
       end
 
       # A single argument with the closing bracket on the same line as the end

data/lib/rubocop/cop/naming/{uncommunicative_block_param_name.rb → block_parameter_name.rb}

@@ -11,9 +11,9 @@ module RuboCop
       # The `AllowNamesEndingInNumbers` config option takes a boolean. When
       # set to false, this cop will register offenses for names ending with
       # numbers. Its default is false. The `AllowedNames` config option
-      # takes an array of whitelisted names that will never register an
+      # takes an array of permitted names that will never register an
       # offense. The `ForbiddenNames` config option takes an array of
-      # blacklisted names that will always register an offense.
+      # restricted names that will always register an offense.
       #
       # @example
       #   # bad
@@ -35,7 +35,7 @@ module RuboCop
       #   foo { |speed, distance| speed * distance }
       #
       #   baz { |age, height, gender| do_stuff(age, height, gender) }
-      class UncommunicativeBlockParamName < Cop
+      class BlockParameterName < Cop
         include UncommunicativeName
 
         def on_block(node)

data/lib/rubocop/cop/naming/file_name.rb

@@ -50,14 +50,11 @@ module RuboCop
         def for_bad_filename(file_path)
           basename = File.basename(file_path)
           msg = if filename_good?(basename)
-                  return unless expect_matching_definition?
-                  return if find_class_or_module(processed_source.ast,
-                                                 to_namespace(file_path))
+                  return if matching_definition?(file_path)
 
                   no_definition_message(basename, file_path)
                 else
-                  return if ignore_executable_scripts? &&
-                            processed_source.start_with?('#!')
+                  return if bad_filename_allowed?
 
                   other_message(basename)
                 end
@@ -65,6 +62,16 @@ module RuboCop
           yield source_range(processed_source.buffer, 1, 0), msg
         end
 
+        def matching_definition?(file_path)
+          return true unless expect_matching_definition?
+
+          find_class_or_module(processed_source.ast, to_namespace(file_path))
+        end
+
+        def bad_filename_allowed?
+          ignore_executable_scripts? && processed_source.start_with?('#!')
+        end
+
         def no_definition_message(basename, file_path)
           format(MSG_NO_DEFINITION,
                  basename: basename,

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Naming
       # This cop checks that your heredocs are using meaningful delimiters.
       # By default it disallows `END` and `EO*`, and can be configured through
-      # blacklisting additional delimiters.
+      # forbidden listing additional delimiters.
       #
       # @example
       #
@@ -41,13 +41,13 @@ module RuboCop
 
           return false unless delimiters =~ /\w/
 
-          blacklisted_delimiters.none? do |blacklisted_delimiter|
-            delimiters =~ Regexp.new(blacklisted_delimiter)
+          forbidden_delimiters.none? do |forbidden_delimiter|
+            delimiters =~ Regexp.new(forbidden_delimiter)
           end
         end
 
-        def blacklisted_delimiters
-          cop_config['Blacklist'] || []
+        def forbidden_delimiters
+          cop_config['ForbiddenDelimiters'] || []
         end
       end
     end

data/lib/rubocop/cop/naming/{uncommunicative_method_param_name.rb → method_parameter_name.rb}

@@ -11,9 +11,9 @@ module RuboCop
       # The `AllowNamesEndingInNumbers` config option takes a boolean. When
       # set to false, this cop will register offenses for names ending with
       # numbers. Its default is false. The `AllowedNames` config option
-      # takes an array of whitelisted names that will never register an
+      # takes an array of permitted names that will never register an
       # offense. The `ForbiddenNames` config option takes an array of
-      # blacklisted names that will always register an offense.
+      # restricted names that will always register an offense.
       #
       # @example
       #   # bad
@@ -43,7 +43,7 @@ module RuboCop
       #   def baz(age_a, height_b, gender_c)
       #     do_stuff(age_a, height_b, gender_c)
       #   end
-      class UncommunicativeMethodParamName < Cop
+      class MethodParameterName < Cop
         include UncommunicativeName
 
         def on_def(node)

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -70,11 +70,11 @@ module RuboCop
           !method_name.match(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
-            predicate_whitelist.include?(method_name)
+            allowed_methods.include?(method_name)
         end
 
         def expected_name(method_name, prefix)
-          new_name = if prefix_blacklist.include?(prefix)
+          new_name = if forbidden_prefixes.include?(prefix)
                        method_name.sub(prefix, '')
                      else
                        method_name.dup
@@ -87,16 +87,16 @@ module RuboCop
           "Rename `#{method_name}` to `#{new_name}`."
         end
 
-        def prefix_blacklist
-          cop_config['NamePrefixBlacklist']
+        def forbidden_prefixes
+          cop_config['ForbiddenPrefixes']
         end
 
         def predicate_prefixes
           cop_config['NamePrefix']
         end
 
-        def predicate_whitelist
-          cop_config['NameWhitelist']
+        def allowed_methods
+          cop_config['AllowedMethods']
         end
 
         def method_definition_macros(macro_name)