rbhint 0.85.1.rc2 → 0.87.1.rc1

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

@@ -3,10 +3,32 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length of a block exceeds some maximum value.
+      # This hint checks if the length of a block exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
-      # The cop can be configured to ignore blocks passed to certain methods.
+      # The hint 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
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks for excessive nesting of conditional and looping
+      # This hint checks for excessive nesting of conditional and looping
       # constructs.
       #
       # You can configure if blocks are considered using the `CountBlocks`

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

@@ -3,11 +3,34 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length a class exceeds some maximum value.
+      # This hint 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)
@@ -22,7 +45,7 @@ module RuboCop
         private
 
         def_node_matcher :class_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const nil? :Class) :new) ...))
+          (casgn nil? _ (block (send (const {nil? cbase} :Class) :new) ...))
         PATTERN
 
         def message(length, max_length)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks that the cyclomatic complexity of methods is not higher
+      # This hint checks that the cyclomatic complexity of methods is not higher
       # than the configured maximum. The cyclomatic complexity is the number of
       # linearly independent paths through a method. The algorithm counts
       # decision points and adds one.

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

@@ -3,9 +3,32 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length of a method exceeds some maximum value.
+      # This hint 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
 

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

@@ -3,11 +3,34 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length a module exceeds some maximum value.
+      # This hint 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)
@@ -22,7 +45,7 @@ module RuboCop
         private
 
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const nil? :Module) :new) ...))
+          (casgn nil? _ (block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks for methods with too many parameters.
+      # This hint checks for methods with too many parameters.
       # The maximum number of parameters is configurable.
       # Keyword arguments can optionally be excluded from the total count.
       class ParameterLists < Cop

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop tries to produce a complexity score that's a measure of the
+      # This hint tries to produce a complexity score that's a measure of the
       # complexity the reader experiences when looking at a method. For that
       # reason it considers `when` nodes as something that doesn't add as much
       # complexity as an `if` or a `&&`. Except if it's one of those special
       # `case`/`when` constructs where there's no expression after `case`. Then
-      # the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
-      # nodes count. In contrast to the CyclomaticComplexity cop, this cop
+      # the hint treats it as an `if`/`elsif`/`elsif`... and lets all the `when`
+      # nodes count. In contrast to the CyclomaticComplexity hint, this hint
       # considers `else` nodes as adding complexity.
       #
       # @example

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

@@ -16,6 +16,10 @@ 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)
 

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

@@ -10,7 +10,9 @@ module RuboCop
         PATTERN
 
         base.def_node_matcher :class_new_definition, <<~PATTERN
-          [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 

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

@@ -7,19 +7,17 @@ module RuboCop
     # 2. Added to NilClass by explicitly requiring any standard libraries
     # 3. Cop's configuration parameter AllowedMethods.
     module NilMethods
+      include AllowedMethods
+
       private
 
       def nil_methods
-        nil.methods + other_stdlib_methods + allowed_methods
+        nil.methods + other_stdlib_methods + allowed_methods.map(&:to_sym)
       end
 
       def other_stdlib_methods
         [:to_d]
       end
-
-      def allowed_methods
-        cop_config['AllowedMethods'].map(&:to_sym)
-      end
     end
   end
 end

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

@@ -15,8 +15,13 @@ module RuboCop
         node.source_range
       end
 
+      def gem_canonical_name(name)
+        name = name.tr('-_', '') unless cop_config['ConsiderPunctuation']
+        name.downcase
+      end
+
       def case_insensitive_out_of_order?(string_a, string_b)
-        string_a.downcase < string_b.downcase
+        gem_canonical_name(string_a) < gem_canonical_name(string_b)
       end
 
       def consecutive_lines(previous, current)

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

@@ -17,9 +17,9 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        node.nonempty_line_count > 3 ||
-          !node.modifier_form? &&
-            processed_source.commented?(node.loc.end)
+        node.modifier_form? ||
+          node.nonempty_line_count > 3 ||
+          processed_source.commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)