rubocop 0.51.0 → 0.87.0

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

@@ -9,12 +9,15 @@ module RuboCop
       class ParameterLists < Cop
         include ConfigurableMax
 
-        MSG = 'Avoid parameter lists longer than %d parameters. [%d/%d]'.freeze
+        MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
+              '[%<count>d/%<max>d]'
 
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
 
+          return if argument_to_lambda_or_proc?(node)
+
           add_offense(node) do
             self.max = count
           end
@@ -22,8 +25,12 @@ module RuboCop
 
         private
 
+        def_node_matcher :argument_to_lambda_or_proc?, <<~PATTERN
+          ^lambda_or_proc?
+        PATTERN
+
         def message(node)
-          format(MSG, max_params, args_count(node), max_params)
+          format(MSG, max: max_params, count: args_count(node))
         end
 
         def args_count(node)

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

@@ -29,7 +29,8 @@ module RuboCop
       class PerceivedComplexity < Cop
         include MethodComplexity
 
-        MSG = 'Perceived complexity for %s is too high. [%d/%d]'.freeze
+        MSG = 'Perceived complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'
         COUNTED_NODES = %i[if case while until
                            for rescue and or].freeze
 
@@ -38,16 +39,15 @@ module RuboCop
         def complexity_score_for(node)
           case node.type
           when :case
-            expression, *whens, _else = *node
             # If cond is nil, that means each when has an expression that
             # evaluates to true or false. It's just an alternative to
             # if/elsif/elsif... so the when nodes count.
-            if expression.nil?
-              whens.length
+            if node.condition.nil?
+              node.when_branches.length
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + 0.2 * whens.length).round
+              (0.8 + 0.2 * node.when_branches.length).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # > ABC is .. a software size metric .. computed by counting the number
+        # > of assignments, branches and conditions for a section of code.
+        # > http://c2.com/cgi/wiki?AbcMetric
+        #
+        # We separate the *calculator* from the *cop* so that the calculation,
+        # the formula itself, is easier to test.
+        class AbcSizeCalculator
+          # > Branch -- an explicit forward program branch out of scope -- a
+          # > function call, class method call ..
+          # > http://c2.com/cgi/wiki?AbcMetric
+          BRANCH_NODES = %i[send csend].freeze
+
+          # > Condition -- a logical/Boolean test, == != <= >= < > else case
+          # > default try catch ? and unary conditionals.
+          # > http://c2.com/cgi/wiki?AbcMetric
+          CONDITION_NODES = (CyclomaticComplexity::COUNTED_NODES - %i[block block_pass]).freeze
+
+          def self.calculate(node)
+            new(node).calculate
+          end
+
+          def initialize(node)
+            @assignment = 0
+            @branch = 0
+            @condition = 0
+            @node = node
+          end
+
+          def calculate
+            @node.each_node do |child|
+              if child.assignment?
+                @assignment += 1
+              elsif branch?(child)
+                evaluate_branch_nodes(child)
+              elsif condition?(child)
+                evaluate_condition_node(child)
+              end
+            end
+
+            [
+              Math.sqrt(@assignment**2 + @branch**2 + @condition**2).round(2),
+              "<#{@assignment}, #{@branch}, #{@condition}>"
+            ]
+          end
+
+          def evaluate_branch_nodes(node)
+            if node.comparison_method?
+              @condition += 1
+            else
+              @branch += 1
+            end
+          end
+
+          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
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # Helps to calculate code length for the provided node.
+        class CodeLengthCalculator
+          extend NodePattern::Macros
+          include Util
+
+          FOLDABLE_TYPES = %i[array hash heredoc].freeze
+          CLASSISH_TYPES = %i[class module].freeze
+
+          def initialize(node, count_comments: false, foldable_types: [])
+            @node = node
+            @count_comments = count_comments
+            @foldable_checks = build_foldable_checks(foldable_types)
+            @foldable_types = normalize_foldable_types(foldable_types)
+          end
+
+          def calculate
+            length = code_length(@node)
+
+            each_top_level_descendant(@node, *@foldable_types, *CLASSISH_TYPES) do |descendant|
+              descendant_length = code_length(descendant)
+
+              if classlike_node?(descendant)
+                length -= (descendant_length + 2)
+              elsif foldable_node?(descendant)
+                length = length - descendant_length + 1
+              end
+            end
+
+            length
+          end
+
+          private
+
+          def_node_matcher :class_definition?, <<~PATTERN
+            (casgn nil? _ (block (send (const nil? :Class) :new) ...))
+          PATTERN
+
+          def_node_matcher :module_definition?, <<~PATTERN
+            (casgn nil? _ (block (send (const nil? :Module) :new) ...))
+          PATTERN
+
+          def build_foldable_checks(types)
+            types.map do |type|
+              case type
+              when :array
+                ->(node) { node.array_type? }
+              when :hash
+                ->(node) { node.hash_type? }
+              when :heredoc
+                ->(node) { heredoc_node?(node) }
+              else
+                raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
+                  "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+              end
+            end
+          end
+
+          def normalize_foldable_types(types)
+            types.concat(%i[str dstr]) if types.delete(:heredoc)
+            types
+          end
+
+          def code_length(node)
+            return heredoc_length(node) if heredoc_node?(node)
+
+            body = extract_body(node)
+            lines = body&.source&.lines || []
+            lines.count { |line| !irrelevant_line?(line) }
+          end
+
+          def heredoc_node?(node)
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          def heredoc_length(node)
+            lines = node.loc.heredoc_body.source.lines
+            lines.count { |line| !irrelevant_line?(line) } + 2
+          end
+
+          def each_top_level_descendant(node, *types, &block)
+            node.each_child_node do |child|
+              if types.include?(child.type)
+                yield child
+              else
+                each_top_level_descendant(child, *types, &block)
+              end
+            end
+          end
+
+          def classlike_node?(node)
+            CLASSISH_TYPES.include?(node.type) ||
+              (node.casgn_type? && (class_definition?(node) || module_definition?(node)))
+          end
+
+          def foldable_node?(node)
+            @foldable_checks.any? { |check| check.call(node) }
+          end
+
+          def extract_body(node)
+            case node.type
+            when :class, :module, :block, :def, :defs
+              node.body
+            when :casgn
+              _scope, _name, value = *node
+              extract_body(value)
+            else
+              node
+            end
+          end
+
+          # Returns true for lines that shall not be included in the count.
+          def irrelevant_line?(source_line)
+            source_line.blank? || !count_comments? && comment_line?(source_line)
+          end
+
+          def count_comments?
+            @count_comments
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # Used to identify iterating blocks like `.map{}` and `.map(&:...)`
+        module IteratingBlock
+          enumerable = %i[
+            all? any? chain chunk chunk_while collect collect_concat count cycle
+            detect drop drop_while each each_cons each_entry each_slice
+            each_with_index each_with_object entries filter filter_map find
+            find_all find_index flat_map grep grep_v group_by inject lazy map
+            max max_by min min_by minmax minmax_by none? one? partition reduce
+            reject reverse_each select slice_after slice_before slice_when sort
+            sort_by sum take take_while tally to_h uniq zip
+          ]
+
+          enumerator = %i[with_index with_object]
+
+          array = %i[
+            bsearch bsearch_index collect! combination d_permutation delete_if
+            each_index keep_if map! permutation product reject! repeat
+            repeated_combination select! sort sort! sort_by sort_by
+          ]
+
+          hash = %i[
+            each_key each_pair each_value fetch fetch_values has_key? merge
+            merge! transform_keys transform_keys! transform_values
+            transform_values!
+          ]
+
+          KNOWN_ITERATING_METHODS = (Set.new(enumerable) + enumerator + array + hash).freeze
+
+          # Returns the name of the method called with a block
+          # if node is a block node, or a block-pass node.
+          def block_method_name(node)
+            case node.type
+            when :block
+              node.method_name
+            when :block_pass
+              node.parent.method_name
+            end
+          end
+
+          # Returns true iff name is a known iterating type (e.g. :each, :transform_values)
+          def iterating_method?(name)
+            KNOWN_ITERATING_METHODS.include? name
+          end
+
+          # Returns nil if node is neither a block node or a block-pass node.
+          # Otherwise returns true/false if method call is a known iterating call
+          def iterating_block?(node)
+            name = block_method_name(node)
+            name && iterating_method?(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/department_name.rb

@@ -0,0 +1,85 @@
+# 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.'
+
+        DISABLE_COMMENT_FORMAT =
+          /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
+
+        # The token that makes up a disable comment.
+        # The allowed specification for comments after `# rubocop: disable` is
+        # `DepartmentName/CopName` or` all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next if comment.text !~ DISABLE_COMMENT_FORMAT
+
+            offset = Regexp.last_match(1).length
+
+            Regexp.last_match(4).scan(/[^,]+|\W+/) do |name|
+              trimmed_name = name.strip
+
+              unless valid_content_token?(trimmed_name)
+                check_cop_name(trimmed_name, comment, offset)
+              end
+
+              break if contain_unexpected_character_for_department_name?(name)
+
+              offset += name.length
+            end
+          end
+        end
+
+        def autocorrect(range)
+          shall_warn = false
+          cop_name = range.source
+          qualified_cop_name = Cop.registry.qualified_cop_name(cop_name,
+                                                               nil, shall_warn)
+          unless qualified_cop_name.include?('/')
+            qualified_cop_name = qualified_legacy_cop_name(cop_name)
+          end
+
+          ->(corrector) { corrector.replace(range, qualified_cop_name) }
+        end
+
+        private
+
+        def disable_comment_offset
+          Regexp.last_match(1).length
+        end
+
+        def check_cop_name(name, comment, offset)
+          start = comment.location.expression.begin_pos + offset
+          range = range_between(start, start + name.length)
+
+          add_offense(range, location: range)
+        end
+
+        def valid_content_token?(content_token)
+          /\W+/.match?(content_token) ||
+            DISABLING_COPS_CONTENT_TOKEN.match?(content_token)
+        end
+
+        def contain_unexpected_character_for_department_name?(name)
+          name.match?(%r{[^A-z/, ]})
+        end
+
+        def qualified_legacy_cop_name(cop_name)
+          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+
+          legacy_cop_names.detect do |legacy_cop_name|
+            legacy_cop_name.split('/')[1] == cop_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for nodes that should be aligned to the left or right.
+    # This amount is determined by the instance variable @column_delta.
+    module Alignment
+      private
+
+      SPACE = ' '
+
+      attr_reader :column_delta
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
+      end
+
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
+      def check_alignment(items, base_column = nil)
+        base_column ||= display_column(items.first.source_range) unless items.empty?
+
+        each_bad_alignment(items, base_column) do |current|
+          expr = current.source_range
+          if offenses.any? { |o| within?(expr, o.location) }
+            # 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 cannot be handled. The next iteration will find the
+            # offense again and correct it.
+            add_offense(nil, location: expr)
+          else
+            add_offense(current)
+          end
+        end
+      end
+
+      def each_bad_alignment(items, base_column)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line &&
+             begins_its_line?(current.source_range)
+            @column_delta = base_column - display_column(current.source_range)
+
+            yield current if @column_delta.nonzero?
+          end
+          prev_line = current.loc.line
+        end
+      end
+
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        Unicode::DisplayWidth.of(line[0, range.column])
+      end
+
+      def within?(inner, outer)
+        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+      end
+
+      def end_of_line_comment(line)
+        processed_source.find_comment { |c| c.loc.line == line }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain methods when
+    # parsing.
+    module AllowedMethods
+      private
+
+      def allowed_method?(name)
+        allowed_methods.include?(name.to_s)
+      end
+
+      def allowed_methods
+        cop_config.fetch('AllowedMethods', [])
+      end
+    end
+  end
+end

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

@@ -16,6 +16,7 @@ module RuboCop
         def split_comment(comment)
           match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
           return false unless match
+
           match.captures
         end
 

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

@@ -48,9 +48,7 @@ module RuboCop
       def smallest_percent_size(style, ary_size)
         @smallest_percent ||= Float::INFINITY
 
-        if style == :percent && ary_size < @smallest_percent
-          @smallest_percent = ary_size
-        end
+        @smallest_percent = ary_size if style == :percent && ary_size < @smallest_percent
 
         @smallest_percent
       end

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

@@ -5,8 +5,10 @@ module RuboCop
     # Common code for ordinary arrays with [] that can be written with %
     # syntax.
     module ArraySyntax
+      private
+
       def bracketed_array_of?(element_type, node)
-        return false unless node.square_brackets? && node.values.size > 1
+        return false unless node.square_brackets? && !node.values.empty?
 
         node.values.all? { |value| value.type == element_type }
       end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # extend this module to signal autocorrection support
+    module AutoCorrector
+      def support_autocorrect?
+        true
+      end
+    end
+  end
+end

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

@@ -4,15 +4,19 @@ module RuboCop
   module Cop
     # Common functionality for checking assignment nodes.
     module CheckAssignment
-      Util::ASGN_NODES.each do |type|
-        define_method("on_#{type}") do |node|
-          check_assignment(node, extract_rhs(node))
-        end
+      def on_lvasgn(node)
+        check_assignment(node, extract_rhs(node))
       end
+      alias on_ivasgn   on_lvasgn
+      alias on_cvasgn   on_lvasgn
+      alias on_gvasgn   on_lvasgn
+      alias on_casgn    on_lvasgn
+      alias on_masgn    on_lvasgn
+      alias on_op_asgn  on_lvasgn
+      alias on_or_asgn  on_lvasgn
+      alias on_and_asgn on_lvasgn
 
       def on_send(node)
-        return unless node.setter_method?
-
         rhs = extract_rhs(node)
 
         return unless rhs
@@ -27,10 +31,10 @@ module RuboCop
           _scope, _lhs, rhs = *node
         elsif node.op_asgn_type?
           _lhs, _op, rhs = *node
-        elsif Util::ASGN_NODES.include?(node.type)
-          _lhs, rhs = *node
-        elsif node.send_type?
+        elsif node.call_type?
           rhs = node.last_argument
+        elsif node.assignment?
+          _lhs, rhs = *node
         end
 
         rhs