rubocop 0.93.1 → 1.79.2

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

@@ -9,7 +9,7 @@ module RuboCop
           extend NodePattern::Macros
           include Util
 
-          FOLDABLE_TYPES = %i[array hash heredoc].freeze
+          FOLDABLE_TYPES = %i[array hash heredoc method_call].freeze
           CLASSLIKE_TYPES = %i[class module].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
@@ -26,10 +26,12 @@ module RuboCop
             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
+              next unless foldable_node?(descendant)
+
+              descendant_length = code_length(descendant)
+              length = length - descendant_length + 1
+              # Subtract length of opening and closing brace if method argument omits hash braces.
+              length -= omit_length(descendant) if descendant.hash_type? && !descendant.braces?
             end
 
             length
@@ -37,28 +39,31 @@ module RuboCop
 
           private
 
-          def build_foldable_checks(types)
+          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
             types.map do |type|
               case type
               when :array
-                ->(node) { node.array_type? }
+                lambda(&:array_type?)
               when :hash
-                ->(node) { node.hash_type? }
+                lambda(&:hash_type?)
               when :heredoc
                 ->(node) { heredoc_node?(node) }
+              when :method_call
+                lambda(&:call_type?)
               else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
-                  "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+                raise Warning, "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.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
             types
           end
 
-          def code_length(node)
+          def code_length(node) # rubocop:disable Metrics/MethodLength
             if classlike_node?(node)
               classlike_code_length(node)
             elsif heredoc_node?(node)
@@ -67,7 +72,14 @@ module RuboCop
               body = extract_body(node)
               return 0 unless body
 
-              body.source.each_line.count { |line| !irrelevant_line?(line) }
+              source =
+                if node_with_heredoc?(body)
+                  source_from_node_with_heredoc(body)
+                else
+                  body.source.lines
+                end
+
+              source.count { |line| !irrelevant_line?(line) }
             end
           end
 
@@ -124,7 +136,7 @@ module RuboCop
           end
 
           def classlike_node?(node)
-            CLASSLIKE_TYPES.include?(node.type)
+            CLASSLIKE_TYPES.include?(node&.type)
           end
 
           def foldable_node?(node)
@@ -133,11 +145,10 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :block, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :itblock, :def, :defs
               node.body
             when :casgn
-              _scope, _name, value = *node
-              extract_body(value)
+              extract_body(node.expression)
             else
               node
             end
@@ -145,12 +156,52 @@ module RuboCop
 
           # 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)
+            source_line.blank? || (!count_comments? && comment_line?(source_line))
           end
 
           def count_comments?
             @count_comments
           end
+
+          def omit_length(descendant)
+            parent = descendant.parent
+            return 0 if another_args?(parent)
+            return 0 unless parenthesized?(parent)
+
+            [
+              parent.loc.begin.end_pos != descendant.source_range.begin_pos,
+              parent.loc.end.begin_pos != descendant.source_range.end_pos
+            ].count(true)
+          end
+
+          def parenthesized?(node)
+            node.call_type? && node.parenthesized?
+          end
+
+          def another_args?(node)
+            node.call_type? && node.arguments.count > 1
+          end
+
+          def node_with_heredoc?(node)
+            node.each_descendant(:str, :dstr).any? { |descendant| heredoc_node?(descendant) }
+          end
+
+          def source_from_node_with_heredoc(node)
+            last_line = -1
+            node.each_descendant do |descendant|
+              next unless descendant.source
+
+              descendant_last_line =
+                if heredoc_node?(descendant)
+                  descendant.loc.heredoc_end.line
+                else
+                  descendant.last_line
+                end
+
+              last_line = [last_line, descendant_last_line].max
+            end
+            @processed_source[(node.first_line - 1)..(last_line - 1)]
+          end
         end
       end
     end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # Identifies repetitions `{c}send` calls with no arguments:
+        #
+        #   foo.bar
+        #   foo.bar # => repeated
+        #   foo.bar.baz.qux # => inner send repeated
+        #   foo.bar.baz.other # => both inner send repeated
+        #   foo.bar(2) # => not repeated
+        #
+        # It also invalidates sequences if a receiver is reassigned:
+        #
+        #   xx.foo.bar
+        #   xx.foo.baz      # => inner send repeated
+        #   self.xx = any   # => invalidates everything so far
+        #   xx.foo.baz      # => no repetition
+        #   self.xx.foo.baz # => all repeated
+        #
+        module RepeatedAttributeDiscount
+          extend NodePattern::Macros
+          include RuboCop::AST::Sexp
+
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
+          # Plug into the calculator
+          def initialize(node, discount_repeated_attributes: false)
+            super(node)
+            return unless discount_repeated_attributes
+
+            self_attributes = {} # Share hash for `(send nil? :foo)` and `(send (self) :foo)`
+            @known_attributes = { s(:self) => self_attributes, nil => self_attributes }
+            # example after running `obj = foo.bar; obj.baz.qux`
+            # { nil => {foo: {bar: {}}},
+            #   s(self) => same hash ^,
+            #   s(:lvar, :obj) => {baz: {qux: {}}}
+            # }
+          end
+
+          def discount_repeated_attributes?
+            defined?(@known_attributes)
+          end
+
+          def evaluate_branch_nodes(node)
+            return if discount_repeated_attributes? && discount_repeated_attribute?(node)
+
+            super
+          end
+
+          def calculate_node(node)
+            update_repeated_attribute(node) if discount_repeated_attributes?
+            super
+          end
+
+          private
+
+          # @!method attribute_call?(node)
+          def_node_matcher :attribute_call?, <<~PATTERN
+            (call _receiver _method # and no parameters
+            )
+          PATTERN
+
+          def discount_repeated_attribute?(send_node)
+            return false unless attribute_call?(send_node)
+
+            repeated = true
+            find_attributes(send_node) do |hash, lookup|
+              return false if hash.nil?
+
+              repeated = false
+              hash[lookup] = {}
+            end
+
+            repeated
+          end
+
+          def update_repeated_attribute(node)
+            return unless (receiver, method = setter_to_getter(node))
+
+            calls = find_attributes(receiver) { return }
+            if method # e.g. `self.foo = 42`
+              calls.delete(method)
+            else      # e.g. `var = 42`
+              calls.clear
+            end
+          end
+
+          # @!method root_node?(node)
+          def_node_matcher :root_node?, <<~PATTERN
+            { nil? | self               # e.g. receiver of `my_method` or `self.my_attr`
+            | lvar | ivar | cvar | gvar # e.g. receiver of `var.my_method`
+            | const }                   # e.g. receiver of `MyConst.foo.bar`
+          PATTERN
+
+          # Returns the "known_attributes" for the `node` by walking the receiver tree
+          # If at any step the subdirectory does not exist, it is yielded with the
+          # associated key (method_name)
+          # If the node is not a series of `(c)send` calls with no arguments,
+          # then `nil` is yielded
+          def find_attributes(node, &block)
+            if attribute_call?(node)
+              calls = find_attributes(node.receiver, &block)
+              value = node.method_name
+            elsif root_node?(node)
+              calls = @known_attributes
+              value = node
+            else
+              return yield nil
+            end
+
+            calls.fetch(value) { yield [calls, value] }
+          end
+
+          # @returns `[receiver, method | nil]` for the given setter `node`
+          # or `nil` if it is not a setter.
+          def setter_to_getter(node)
+            if (type = VAR_SETTER_TO_GETTER[node.type])
+              # (lvasgn :my_var (int 42)) => [(lvar my_var), nil]
+              [s(type, node.children.first), nil]
+            elsif node.shorthand_asgn? # (or-asgn (send _receiver :foo) _value)
+              # (or-asgn (send _receiver :foo) _value) => [_receiver, :foo]
+              node.children.first.children
+            elsif node.respond_to?(:setter_method?) && node.setter_method?
+              # (send _receiver :foo= (int 42) ) => [_receiver, :foo]
+              method_name = node.method_name[0...-1].to_sym
+              [node.receiver, method_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,12 @@ module RuboCop
       module Utils
         # @api private
         #
-        # Helps to calculate code length for the provided node.
+        # Identifies repetitions `&.` on the same variable:
+        #
+        #  my_var&.foo
+        #  my_var&.bar # => repeated
+        #  my_var = baz # => reset
+        #  my_var&.qux # => not repeated
         module RepeatedCsendDiscount
           def reset_repeated_csend
             @repeated_csend = {}

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

@@ -11,13 +11,12 @@ module RuboCop
 
         MSG = 'Department name is missing.'
 
-        DISABLE_COMMENT_FORMAT =
-          /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
+        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
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-Za-z]+/[A-Za-z]+|all}.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
@@ -46,7 +45,7 @@ module RuboCop
         end
 
         def check_cop_name(name, comment, offset)
-          start = comment.location.expression.begin_pos + offset
+          start = comment.source_range.begin_pos + offset
           range = range_between(start, start + name.length)
 
           add_offense(range) do |corrector|
@@ -63,19 +62,18 @@ module RuboCop
 
         def valid_content_token?(content_token)
           /\W+/.match?(content_token) ||
-            DISABLING_COPS_CONTENT_TOKEN.match?(content_token)
+            DISABLING_COPS_CONTENT_TOKEN.match?(content_token) ||
+            Registry.global.department?(content_token)
         end
 
         def contain_unexpected_character_for_department_name?(name)
-          name.match?(%r{[^A-z/, ]})
+          name.match?(%r{[^A-Za-z/, ]})
         end
 
         def qualified_legacy_cop_name(cop_name)
-          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+          legacy_cop_names = RuboCop::ConfigObsoletion.legacy_cop_names
 
-          legacy_cop_names.detect do |legacy_cop_name|
-            legacy_cop_name.split('/')[1] == cop_name
-          end
+          legacy_cop_names.detect { |legacy_cop_name| legacy_cop_name.split('/')[1] == cop_name }
         end
       end
     end

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

@@ -5,15 +5,14 @@ module RuboCop
     # 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 = ' '
 
+      private
+
       attr_reader :column_delta
 
       def configured_indentation_width
-        cop_config['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width']
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
       def indentation(node)
@@ -29,15 +28,15 @@ module RuboCop
 
         each_bad_alignment(items, base_column) do |current|
           expr = current.source_range
-          if offenses.any? { |o| within?(expr, o.location) }
+          if @current_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)
+            register_offense(expr, nil)
           else
-            add_offense(current)
+            register_offense(current, current)
           end
         end
       end
@@ -46,8 +45,7 @@ module RuboCop
       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)
+          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?
@@ -67,10 +65,21 @@ module RuboCop
         inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
       end
 
-      # @deprecated Use processed_source.comment_at_line(line)
-      def end_of_line_comment(line)
+      # @deprecated Use processed_source.line_with_comment?(line)
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
+        WARNING
+
         processed_source.line_with_comment?(line)
       end
+
+      # @api private
+      def register_offense(offense_node, message_node)
+        add_offense(offense_node, message: message(message_node)) do |corrector|
+          autocorrect(corrector, message_node)
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain identifiers in a cop.
+    module AllowedIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def allowed_identifier?(name)
+        !allowed_identifiers.empty? && allowed_identifiers.include?(name.to_s.delete(SIGILS))
+      end
+
+      def allowed_identifiers
+        cop_config.fetch('AllowedIdentifiers') { [] }
+      end
+    end
+  end
+end

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     # This module encapsulates the ability to allow certain methods when
-    # parsing.
+    # parsing. Even if the code is in offense, if it contains methods
+    # that are allowed. This module is equivalent to the IgnoredMethods module,
+    # which will be deprecated in RuboCop 2.0.
     module AllowedMethods
       private
 
@@ -12,10 +14,35 @@ module RuboCop
         allowed_methods.include?(name.to_s)
       end
 
+      # @deprecated Use allowed_method? instead
+      def ignored_method?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_method?` is deprecated. Use `allowed_method?` instead.
+        WARNING
+
+        allowed_method?
+      end
+
       # @api public
       def allowed_methods
-        cop_config.fetch('AllowedMethods', [])
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
+        else
+          cop_config_allowed_methods + cop_config_deprecated_values
+        end
+      end
+
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
+      def cop_config_deprecated_values
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
       end
     end
+    # @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+    IgnoredMethods = AllowedMethods
   end
 end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain lines when
+    # parsing.
+    module AllowedPattern
+      private
+
+      def allowed_line?(line)
+        line = if line.respond_to?(:source_line)
+                 line.source_line
+               elsif line.respond_to?(:node)
+                 line.node.source_range.source_line
+               end
+
+        matches_allowed_pattern?(line)
+      end
+
+      # @deprecated Use allowed_line? instead
+      def ignored_line?(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_line?` is deprecated. Use `allowed_line?` instead.
+        WARNING
+
+        allowed_line?(line)
+      end
+
+      def matches_allowed_pattern?(line)
+        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+      end
+
+      # @deprecated Use matches_allowed_pattern? instead
+      def matches_ignored_pattern?(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
+        WARNING
+
+        matches_allowed_pattern?(line)
+      end
+
+      def allowed_patterns
+        # Since there could be a pattern specified in the default config, merge the two
+        # arrays together.
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
+
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
+      end
+
+      def cop_config_deprecated_methods_values
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
+      end
+    end
+
+    # @deprecated IgnoredPattern class has been replaced with AllowedPattern.
+    IgnoredPattern = AllowedPattern
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain receivers in a cop.
+    module AllowedReceivers
+      def allowed_receiver?(receiver)
+        receiver_name = receiver_name(receiver)
+
+        allowed_receivers.include?(receiver_name)
+      end
+
+      def receiver_name(receiver)
+        if receiver.receiver && !receiver.receiver.const_type?
+          return receiver_name(receiver.receiver)
+        end
+
+        if receiver.send_type?
+          if receiver.receiver
+            "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+          else
+            receiver.method_name.to_s
+          end
+        else
+          receiver.source
+        end
+      end
+
+      def allowed_receivers
+        cop_config.fetch('AllowedReceivers', [])
+      end
+    end
+  end
+end