rubocop 0.74.0 → 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

@@ -6,55 +6,36 @@ module RuboCop
       # This cop checks for operators, variables, literals, and nonmutating
       # methods used in void context.
       #
-      # @example
-      #
+      # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
-      #
       #   def some_method
       #     some_num * 10
       #     do_something
       #   end
       #
-      # @example
-      #
-      #   # bad
-      #
       #   def some_method(some_var)
       #     some_var
       #     do_something
       #   end
       #
-      # @example
-      #
-      #   # bad, when CheckForMethodsWithNoSideEffects is set true
-      #
+      # @example CheckForMethodsWithNoSideEffects: true
+      #   # bad
       #   def some_method(some_array)
       #     some_array.sort
       #     do_something(some_array)
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def some_method
       #     do_something
       #     some_num * 10
       #   end
       #
-      # @example
-      #
-      #   # good
-      #
       #   def some_method(some_var)
       #     do_something
       #     some_var
       #   end
       #
-      # @example
-      #
-      #   # good, when CheckForMethodsWithNoSideEffects is set true
-      #
       #   def some_method(some_array)
       #     some_array.sort!
       #     do_something(some_array)
@@ -74,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/message_annotator.rb

@@ -9,11 +9,11 @@ module RuboCop
     #
     # @example
     #   RuboCop::Cop::MessageAnnotator.new(
-    #     config, cop_config, @options
-    #   ).annotate('message', 'Cop/CopName')
+    #     config, cop_name, cop_config, @options
+    #   ).annotate('message')
     #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
     class MessageAnnotator
-      attr_reader :options, :config, :cop_config
+      attr_reader :options, :config, :cop_name, :cop_config
 
       @style_guide_urls = {}
 
@@ -29,6 +29,7 @@ module RuboCop
       #     :ExtraDetails [Boolean] Include cop details
       #     :DisplayCopNames [Boolean] Include cop name
       #
+      # @param [String] cop_name for specific cop name
       # @param [Hash] cop_config configs for specific cop, from config#for_cop
       # @option cop_config [String] :StyleGuide Extension of base styleguide URL
       # @option cop_config [String] :Reference Full reference URL
@@ -43,8 +44,9 @@ module RuboCop
       #   Include debug output
       # @option options [Boolean] :display_cop_names
       #   Include cop name
-      def initialize(config, cop_config, options)
+      def initialize(config, cop_name, cop_config, options)
         @config = config
+        @cop_name = cop_name
         @cop_config = cop_config || {}
         @options = options
       end
@@ -53,8 +55,8 @@ module RuboCop
       # based on params passed into initializer
       #
       # @return [String] annotated message
-      def annotate(message, name)
-        message = "#{name}: #{message}" if display_cop_names?
+      def annotate(message)
+        message = "#{cop_name}: #{message}" if display_cop_names?
         message += " #{details}" if extra_details? && details
         if display_style_guide?
           links = urls.join(', ')
@@ -74,7 +76,7 @@ module RuboCop
         return nil if url.nil? || url.empty?
 
         self.class.style_guide_urls[url] ||= begin
-          base_url = config.for_all_cops['StyleGuideBaseURL']
+          base_url = style_guide_base_url
           if base_url.nil? || base_url.empty?
             url
           else
@@ -83,6 +85,13 @@ module RuboCop
         end
       end
 
+      def style_guide_base_url
+        department_name = cop_name.split('/').first
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
       def display_style_guide?
         (options[:display_style_guide] ||
          config.for_all_cops['DisplayStyleGuide']) &&

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/migration/department_name.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Migration
+      # Check that cop names in rubocop:disable comments are given with
+      # department name.
+      class DepartmentName < Cop
+        include RangeHelp
+
+        MSG = 'Department name is missing.'
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+
+            offset = Regexp.last_match(1).length
+            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
+              check_cop_name(name, comment, offset)
+              offset += name.length
+            end
+          end
+        end
+
+        def autocorrect(range)
+          shall_warn = false
+          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
+                                                               nil, shall_warn)
+          ->(corrector) { corrector.replace(range, qualified_cop_name) }
+        end
+
+        private
+
+        def check_cop_name(name, comment, offset)
+          return if name !~ /^[A-Z]/ || name =~ %r{/}
+
+          start = comment.location.expression.begin_pos + offset
+          range = range_between(start, start + name.length)
+          add_offense(range, location: range)
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module RuboCop
 
       def configured_indentation_width
         cop_config['IndentationWidth'] ||
-          config.for_cop('IndentationWidth')['Width']
+          config.for_cop('Layout/IndentationWidth')['Width']
       end
 
       def indentation(node)
@@ -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/frozen_string_literal.rb

@@ -12,7 +12,7 @@ module RuboCop
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal_specified?
+          MagicComment.parse(line).valid_literal_value?
         end
       end
 

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