rubocop 0.85.1 → 0.89.0

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

@@ -0,0 +1,157 @@
+# 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
+          CLASSLIKE_TYPES = %i[class module].freeze
+
+          def initialize(node, processed_source, count_comments: false, foldable_types: [])
+            @node = node
+            @processed_source = processed_source
+            @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)
+            return length if @foldable_types.empty?
+
+            each_top_level_descendant(@node, @foldable_types) do |descendant|
+              if foldable_node?(descendant)
+                descendant_length = code_length(descendant)
+                length = length - descendant_length + 1
+              end
+            end
+
+            length
+          end
+
+          private
+
+          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)
+            if classlike_node?(node)
+              classlike_code_length(node)
+            elsif heredoc_node?(node)
+              heredoc_length(node)
+            else
+              body = extract_body(node)
+              return 0 unless body
+
+              body.source.each_line.count { |line| !irrelevant_line?(line) }
+            end
+          end
+
+          def heredoc_node?(node)
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          def classlike_code_length(node)
+            return 0 if namespace_module?(node)
+
+            body_line_numbers = line_range(node).to_a[1...-1]
+
+            target_line_numbers = body_line_numbers -
+                                  line_numbers_of_inner_nodes(node, :module, :class)
+
+            target_line_numbers.reduce(0) do |length, line_number|
+              source_line = @processed_source[line_number]
+              next length if irrelevant_line?(source_line)
+
+              length + 1
+            end
+          end
+
+          def namespace_module?(node)
+            classlike_node?(node.body)
+          end
+
+          def line_numbers_of_inner_nodes(node, *types)
+            line_numbers = Set.new
+
+            node.each_descendant(*types) do |inner_node|
+              line_range = line_range(inner_node)
+              line_numbers.merge(line_range)
+            end
+
+            line_numbers.to_a
+          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|
+              next if classlike_node?(child)
+
+              if types.include?(child.type)
+                yield child
+              else
+                each_top_level_descendant(child, types, &block)
+              end
+            end
+          end
+
+          def classlike_node?(node)
+            CLASSLIKE_TYPES.include?(node.type)
+          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/metrics/utils/repeated_csend_discount.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # Helps to calculate code length for the provided node.
+        module RepeatedCsendDiscount
+          def reset_repeated_csend
+            @repeated_csend = {}
+          end
+
+          def discount_for_repeated_csend?(csend_node)
+            receiver = csend_node.receiver
+
+            return false unless receiver.lvar_type?
+
+            var_name = receiver.children.first
+            seen = @repeated_csend.fetch(var_name) do
+              @repeated_csend[var_name] = csend_node
+              return false
+            end
+
+            !seen.equal?(csend_node)
+          end
+
+          def reset_on_lvasgn(node)
+            var_name = node.children.first
+            @repeated_csend.delete(var_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,8 +5,9 @@ module RuboCop
     module Migration
       # Check that cop names in rubocop:disable comments are given with
       # department name.
-      class DepartmentName < Cop
+      class DepartmentName < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Department name is missing.'
 
@@ -18,7 +19,7 @@ module RuboCop
         # `DepartmentName/CopName` or` all`.
         DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.each_comment do |comment|
             next if comment.text !~ DISABLE_COMMENT_FORMAT
 
@@ -38,18 +39,6 @@ module RuboCop
           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
@@ -60,7 +49,16 @@ module RuboCop
           start = comment.location.expression.begin_pos + offset
           range = range_between(start, start + name.length)
 
-          add_offense(range, location: range)
+          add_offense(range) do |corrector|
+            cop_name = range.source
+            qualified_cop_name = Cop.registry.qualified_cop_name(cop_name, nil, warn: false)
+
+            unless qualified_cop_name.include?('/')
+              qualified_cop_name = qualified_legacy_cop_name(cop_name)
+            end
+
+            corrector.replace(range, qualified_cop_name)
+          end
         end
 
         def valid_content_token?(content_token)

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/array_min_size.rb

@@ -16,7 +16,7 @@ module RuboCop
         cop_config['MinSize']
       end
 
-      def array_style_detected(style, ary_size)
+      def array_style_detected(style, ary_size) # rubocop:todo Metrics/AbcSize
         cfg = config_to_allow_offenses
         return if cfg['Enabled'] == false
 

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_line_breakable.rb

@@ -171,7 +171,7 @@ module RuboCop
         # ...then each key/value pair is treated as a method 'argument'
         # when determining where line breaks should appear.
         if (last_arg = args.last)
-          args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
+          args = args[0...-1] + last_arg.children if last_arg.hash_type? && !last_arg.braces?
         end
         args
       end

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

@@ -6,8 +6,14 @@ module RuboCop
     module CodeLength
       include ConfigurableMax
 
+      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'
+
       private
 
+      def message(length, max_length)
+        format(MSG, label: cop_label, length: length, max: max_length)
+      end
+
       def max_length
         cop_config['Max']
       end
@@ -16,15 +22,21 @@ module RuboCop
         cop_config['CountComments']
       end
 
+      def count_as_one
+        Array(cop_config['CountAsOne']).map(&:to_sym)
+      end
+
       def check_code_length(node)
-        length = code_length(node)
+        # Skip costly calculation when definitely not needed
+        return if node.line_count <= max_length
 
-        return unless length > max_length
+        calculator = build_code_length_calculator(node)
+        length = calculator.calculate
+        return if length <= max_length
 
-        location = node.casgn_type? ? :name : :expression
+        location = node.casgn_type? ? node.loc.name : node.loc.expression
 
-        add_offense(node, location: location,
-                          message: message(length, max_length)) do
+        add_offense(location, message: message(length, max_length)) do
           self.max = length
         end
       end
@@ -33,6 +45,15 @@ module RuboCop
       def irrelevant_line(source_line)
         source_line.blank? || !count_comments? && comment_line?(source_line)
       end
+
+      def build_code_length_calculator(node)
+        Metrics::Utils::CodeLengthCalculator.new(
+          node,
+          processed_source,
+          count_comments: count_comments?,
+          foldable_types: count_as_one
+        )
+      end
     end
   end
 end

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

@@ -10,7 +10,7 @@ module RuboCop
         if valid_name?(node, name)
           correct_style_detected
         else
-          add_offense(node, location: name_range, message: message(style)) do
+          add_offense(name_range, message: message(style)) do
             report_opposing_styles(node, name)
           end
         end

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

@@ -9,7 +9,7 @@ module RuboCop
 
       FORMATS = {
         snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+        camelCase:  /^@{0,2}(?:_|_?[a-z][\da-zA-Z]*)[!?=]?$/
       }.freeze
     end
   end

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

@@ -41,11 +41,11 @@ module RuboCop
       end
 
       def interpreter_directive_comment?(comment)
-        comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+        /^#\s*(frozen_string_literal|encoding):/.match?(comment.text)
       end
 
       def rubocop_directive_comment?(comment)
-        comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+        CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
       end
     end
   end