rubocop 0.51.0 → 0.87.0

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
       #
+      # NOTE: There are edge cases in which the local variable references a
+      # value that is also accessible outside the local scope. This is not
+      # detected by the cop, and it can yield a false positive.
+      #
       # @example
       #
       #   # bad
@@ -25,7 +29,7 @@ module RuboCop
       #     x
       #   end
       class UselessSetterCall < Cop
-        MSG = 'Useless setter call to local variable `%s`.'.freeze
+        MSG = 'Useless setter call to local variable `%<variable>s`.'
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
         def on_def(node)
@@ -42,26 +46,23 @@ module RuboCop
           add_offense(
             receiver,
             location: :name,
-            message: format(MSG, receiver.loc.name.source)
+            message: format(MSG, variable: receiver.loc.name.source)
           )
         end
         alias on_defs on_def
 
         private
 
+        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
+          [(send (lvar _) ...) setter_method?]
+        PATTERN
+
         def last_expression(body)
           expression = body.begin_type? ? body.children : body
 
           expression.is_a?(Array) ? expression.last : expression
         end
 
-        def setter_call_to_local_variable?(node)
-          return unless node && node.send_type?
-          return unless node.receiver && node.receiver.lvar_type?
-
-          node.method_name =~ /(?:\w|\[\])=$/
-        end
-
         # This class tracks variable assignments in a method body
         # and if a variable contains object passed as argument at the end of
         # the method.
@@ -127,6 +128,7 @@ module RuboCop
           def process_logical_operator_assignment(asgn_node)
             lhs_node, rhs_node = *asgn_node
             return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
             process_assignment(lhs_node, rhs_node)
 
             throw :skip_children
@@ -135,6 +137,7 @@ module RuboCop
           def process_binary_operator_assignment(op_asgn_node)
             lhs_node, = *op_asgn_node
             return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
+
             lhs_variable_name, = *lhs_node
             @local[lhs_variable_name] = true
 
@@ -155,8 +158,8 @@ module RuboCop
           def constructor?(node)
             return true if node.literal?
             return false unless node.send_type?
-            _receiver, method = *node
-            method == :new
+
+            node.method?(:new)
           end
         end
       end

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

@@ -3,55 +3,70 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for operators, variables and literals used
-      # in void context.
-      #
-      # @example
+      # This cop checks for operators, variables, literals, and nonmutating
+      # methods used in void context.
       #
+      # @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
+      # @example CheckForMethodsWithNoSideEffects: true
+      #   # bad
+      #   def some_method(some_array)
+      #     some_array.sort
+      #     do_something(some_array)
+      #   end
       #
       #   # good
-      #
       #   def some_method
       #     do_something
       #     some_num * 10
       #   end
       #
-      # @example
-      #
-      #   # good
-      #
       #   def some_method(some_var)
       #     do_something
       #     some_var
       #   end
+      #
+      #   def some_method(some_array)
+      #     some_array.sort!
+      #     do_something(some_array)
+      #   end
       class Void < Cop
-        OP_MSG = 'Operator `%s` used in void context.'.freeze
-        VAR_MSG = 'Variable `%s` used in void context.'.freeze
-        LIT_MSG = 'Literal `%s` used in void context.'.freeze
-        SELF_MSG = '`self` used in void context.'.freeze
-        DEFINED_MSG = '`%s` used in void context.'.freeze
+        OP_MSG = 'Operator `%<op>s` used in void context.'
+        VAR_MSG = 'Variable `%<var>s` used in void context.'
+        LIT_MSG = 'Literal `%<lit>s` used in void context.'
+        SELF_MSG = '`self` used in void context.'
+        DEFINED_MSG = '`%<defined>s` used in void context.'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. ' \
+          'Did you mean `#%<method>s!`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
         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 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)
+          return unless node.body && !node.body.begin_type?
+          return unless in_void_context?(node.body)
+
+          check_expression(node.body)
+        end
 
         def on_begin(node)
           check_begin(node)
@@ -62,22 +77,29 @@ module RuboCop
 
         def check_begin(node)
           expressions = *node
-          expressions = expressions.drop_last(1) unless in_void_context?(node)
+          expressions.pop unless in_void_context?(node)
           expressions.each do |expr|
-            check_void_op(expr)
-            check_literal(expr)
-            check_var(expr)
-            check_self(expr)
-            check_defined(expr)
+            check_expression(expr)
           end
         end
 
+        def check_expression(expr)
+          check_void_op(expr)
+          check_literal(expr)
+          check_var(expr)
+          check_self(expr)
+          check_defined(expr)
+          return unless cop_config['CheckForMethodsWithNoSideEffects']
+
+          check_nonmutating(expr)
+        end
+
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 
           add_offense(node,
                       location: :selector,
-                      message: format(OP_MSG, node.method_name))
+                      message: format(OP_MSG, op: node.method_name))
         end
 
         def check_var(node)
@@ -85,13 +107,13 @@ module RuboCop
 
           add_offense(node,
                       location: :name,
-                      message: format(VAR_MSG, node.loc.name.source))
+                      message: format(VAR_MSG, var: node.loc.name.source))
         end
 
         def check_literal(node)
           return if !node.literal? || node.xstr_type?
 
-          add_offense(node, message: format(LIT_MSG, node.source))
+          add_offense(node, message: format(LIT_MSG, lit: node.source))
         end
 
         def check_self(node)
@@ -103,7 +125,17 @@ module RuboCop
         def check_defined(node)
           return unless node.defined_type?
 
-          add_offense(node, message: format(DEFINED_MSG, node.source))
+          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+        end
+
+        def check_nonmutating(node)
+          unless node.send_type? &&
+                 NONMUTATING_METHODS.include?(node.method_name)
+            return
+          end
+
+          add_offense(node, message: format(NONMUTATING_MSG,
+                                            method: node.method_name))
         end
 
         def in_void_context?(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(', ')
@@ -64,7 +66,7 @@ module RuboCop
       end
 
       def urls
-        [style_guide_url, reference_url].compact
+        [style_guide_url, *reference_urls].compact
       end
 
       private
@@ -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,15 +85,22 @@ 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']) &&
           !urls.empty?
       end
 
-      def reference_url
-        url = cop_config['Reference']
-        url.nil? || url.empty? ? nil : url
+      def reference_urls
+        urls = Array(cop_config['Reference'])
+        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
       end
 
       def extra_details?
@@ -103,8 +112,12 @@ module RuboCop
       end
 
       def display_cop_names?
-        debug? || options[:display_cop_names] ||
-          config.for_all_cops['DisplayCopNames']
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if options[:display_cop_names]
+        return false if options[:format] == 'json'
+
+        config.for_all_cops['DisplayCopNames']
       end
 
       def details

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

@@ -6,32 +6,17 @@ module RuboCop
       # This cop checks that the ABC size of methods is not higher than the
       # configured maximum. The ABC size is based on assignments, branches
       # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
       class AbcSize < Cop
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %s is too high. ' \
-              '[%.4g/%.4g]'.freeze
-        BRANCH_NODES = %i[send csend].freeze
-        CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<abc_vector>s %<complexity>.4g/%<max>.4g]'
 
         private
 
         def complexity(node)
-          assignment = 0
-          branch = 0
-          condition = 0
-
-          node.each_node do |child|
-            if child.assignment?
-              assignment += 1
-            elsif BRANCH_NODES.include?(child.type)
-              branch += 1
-            elsif CONDITION_NODES.include?(child.type)
-              condition += 1
-            end
-          end
-
-          Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
+          Utils::AbcSizeCalculator.calculate(node)
         end
       end
     end

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

@@ -7,18 +7,58 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       # The cop can be configured to ignore blocks passed to certain methods.
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   something do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
       class BlockLength < Cop
         include TooManyLines
 
-        LABEL = 'Block'.freeze
+        LABEL = 'Block'
 
         def on_block(node)
-          return if excluded_methods.include?(node.send_node.method_name.to_s)
+          return if excluded_method?(node)
+          return if node.class_constructor?
+
           check_code_length(node)
         end
 
         private
 
+        def excluded_method?(node)
+          node_receiver = node.receiver&.source&.gsub(/\s+/, '')
+          node_method = String(node.method_name)
+
+          excluded_methods.any? do |config|
+            receiver, method = config.split('.')
+
+            unless method
+              method = receiver
+              receiver = node_receiver
+            end
+
+            method == node_method && receiver == node_receiver
+          end
+        end
+
         def excluded_methods
           cop_config['ExcludedMethods'] || []
         end

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

@@ -20,7 +20,8 @@ module RuboCop
         ].freeze
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
+
           max = cop_config['Max']
           check_nesting_level(processed_source.ast, max, 0)
         end

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

@@ -6,17 +6,52 @@ module RuboCop
       # This cop checks if the length a class exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   class Foo
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
+      #
       class ClassLength < Cop
-        include ClassishLength
+        include TooManyLines
 
         def on_class(node)
           check_code_length(node)
         end
 
+        def on_casgn(node)
+          class_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
         private
 
+        def_node_matcher :class_definition?, <<~PATTERN
+          (casgn nil? _ (block (send (const {nil? cbase} :Class) :new) ...))
+        PATTERN
+
         def message(length, max_length)
-          format('Class has too many lines. [%d/%d]', length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
         end
       end
     end

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

@@ -13,18 +13,51 @@ module RuboCop
       # operator (or keyword and) can be converted to a nested if statement,
       # and ||/or is shorthand for a sequence of ifs, so they also add one.
       # Loops can be said to have an exit condition, so they add one.
+      # Blocks that are calls to builtin iteration methods
+      # (e.g. `ary.map{...}) also add one, others are ignored.
+      #
+      #   def each_child_node(*types)               # count begins: 1
+      #     unless block_given?                     # unless: +1
+      #       return to_enum(__method__, *types)
+      #
+      #     children.each do |child|                # each{}: +1
+      #       next unless child.is_a?(Node)         # unless: +1
+      #
+      #       yield child if types.empty? ||        # if: +1, ||: +1
+      #                      types.include?(child.type)
+      #     end
+      #
+      #     self
+      #   end                                       # total: 6
       class CyclomaticComplexity < Cop
         include MethodComplexity
+        include Utils::IteratingBlock
 
-        MSG = 'Cyclomatic complexity for %s is too high. [%d/%d]'.freeze
-        COUNTED_NODES = %i[if while until for
-                           rescue when and or].freeze
+        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if while until for csend block block_pass
+                           rescue when and or or_asgn and_asgn].freeze
 
         private
 
-        def complexity_score_for(_node)
+        def complexity_score_for(node)
+          return 0 if iterating_block?(node) == false
+
           1
         end
+
+        def block_method(node)
+          case node.type
+          when :block
+            node.method_name
+          when :block_pass
+            node.parent.method_name
+          end
+        end
+
+        def count_block?(block)
+          KNOWN_ITERATING_METHODS.include? block.method_name
+        end
       end
     end
   end

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

@@ -6,18 +6,45 @@ module RuboCop
       # This cop checks if the length of a method exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   def m
+      #     array = [       # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {        # +3
+      #       key: 'value'
+      #     }
+      #
+      #     <<~HEREDOC      # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end               # 5 points
+      #
       class MethodLength < Cop
         include TooManyLines
 
-        LABEL = 'Method'.freeze
+        LABEL = 'Method'
 
         def on_def(node)
+          excluded_methods = cop_config['ExcludedMethods']
+          return if excluded_methods.include?(String(node.method_name))
+
           check_code_length(node)
         end
         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/module_length.rb

@@ -6,17 +6,52 @@ module RuboCop
       # This cop checks if the length a module exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
+      #
+      # You can set literals you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # will be counted as one line regardless of its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc']
+      #
+      #   module M
+      #     ARRAY = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     HASH = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     MSG = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #   end                 # 5 points
+      #
       class ModuleLength < Cop
-        include ClassishLength
+        include TooManyLines
 
         def on_module(node)
           check_code_length(node)
         end
 
+        def on_casgn(node)
+          module_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
         private
 
+        def_node_matcher :module_definition?, <<~PATTERN
+          (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
+        PATTERN
+
         def message(length, max_length)
-          format('Module has too many lines. [%d/%d]', length, max_length)
+          format('Module has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
         end
       end
     end