rubocop 1.27.0 → 1.51.0

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

@@ -9,8 +9,8 @@ module RuboCop
           extend NodePattern::Macros
           include Util
 
-          FOLDABLE_TYPES = %i[array hash heredoc].freeze
-          CLASSLIKE_TYPES = %i[class module].freeze
+          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
+          CLASSLIKE_TYPES = %i[class module sclass].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
           def initialize(node, processed_source, count_comments: false, foldable_types: [])
@@ -30,8 +30,8 @@ module RuboCop
 
               descendant_length = code_length(descendant)
               length = length - descendant_length + 1
-              # Subtract 2 length of opening and closing brace if method argument omits hash braces.
-              length -= 2 if descendant.hash_type? && !descendant.braces?
+              # 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
@@ -39,7 +39,7 @@ 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
@@ -48,15 +48,18 @@ module RuboCop
                 ->(node) { node.hash_type? }
               when :heredoc
                 ->(node) { heredoc_node?(node) }
+              when :method_call
+                ->(node) { node.call_type? }
               else
-                raise ArgumentError, "Unknown foldable type: #{type.inspect}. "\
+                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.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
             types
           end
 
@@ -153,6 +156,25 @@ module RuboCop
           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
         end
       end
     end

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

@@ -45,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|

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

@@ -12,7 +12,7 @@ module RuboCop
       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)
@@ -28,7 +28,7 @@ module RuboCop
 
         each_bad_alignment(items, base_column) do |current|
           expr = current.source_range
-          if @current_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

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

@@ -7,11 +7,11 @@ module RuboCop
       SIGILS = '@$' # if a variable starts with a sigil it will be removed
 
       def allowed_identifier?(name)
-        allowed_identifiers.include?(name.to_s.delete(SIGILS))
+        !allowed_identifiers.empty? && allowed_identifiers.include?(name.to_s.delete(SIGILS))
       end
 
       def allowed_identifiers
-        cop_config.fetch('AllowedIdentifiers', [])
+        cop_config.fetch('AllowedIdentifiers') { [] }
       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,29 @@ module RuboCop
         allowed_methods.include?(name.to_s)
       end
 
+      # @deprecated Use allowed_method? instead
+      alias ignored_method? allowed_method?
+
       # @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,56 @@
+# 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
+      alias ignored_line? allowed_line?
+
+      def matches_allowed_pattern?(line)
+        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+      end
+
+      # @deprecated Use matches_allowed_pattern?? instead
+      alias matches_ignored_pattern? matches_allowed_pattern?
+
+      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/annotation_comment.rb

@@ -29,7 +29,7 @@ module RuboCop
 
       # Returns the range bounds for just the annotation
       def bounds
-        start = comment.loc.expression.begin_pos + margin.length
+        start = comment.source_range.begin_pos + margin.length
         length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
         [start, start + length]
       end
@@ -41,18 +41,25 @@ module RuboCop
       def split_comment(comment)
         # Sort keywords by reverse length so that if a keyword is in a phrase
         # but also on its own, both will match properly.
-        keywords_regex = Regexp.new(
-          Regexp.union(keywords.sort_by { |w| -w.length }).source,
-          Regexp::IGNORECASE
-        )
-        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
-
         match = comment.text.match(regex)
         return false unless match
 
         match.captures
       end
 
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      private_constant :KEYWORDS_REGEX_CACHE
+
+      def regex
+        KEYWORDS_REGEX_CACHE[keywords] ||= begin
+          keywords_regex = Regexp.new(
+            Regexp.union(keywords.sort_by { |w| -w.length }).source,
+            Regexp::IGNORECASE
+          )
+          /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+        end
+      end
+
       def keyword_appearance?
         keyword && (colon || space)
       end

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

@@ -46,6 +46,8 @@ module RuboCop
         if node.send_type?
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
+        elsif node.def_type?
+          return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.array_type? || node.hash_type?
           return extract_breakable_node_from_elements(node, node.children, max)
         end
@@ -216,7 +218,9 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        node.first_line != node.last_line
+        return node.first_line != node.arguments.last.last_line if node.def_type?
+
+        !node.single_line?
       end
     end
   end

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

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.loc.expression
+        location = node.casgn_type? ? node.loc.name : node.source_range
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end

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

@@ -12,16 +12,32 @@ module RuboCop
       end
 
       def contains_comments?(node)
+        comments_in_range(node).any?
+      end
+
+      def comments_in_range(node)
         start_line = node.source_range.line
         end_line = find_end_line(node)
 
-        processed_source.each_comment_in_lines(start_line...end_line).any?
+        processed_source.each_comment_in_lines(start_line...end_line)
+      end
+
+      def comments_contain_disables?(node, cop_name)
+        disabled_ranges = processed_source.disabled_line_ranges[cop_name]
+
+        return unless disabled_ranges
+
+        node_range = node.source_range.line...find_end_line(node)
+
+        disabled_ranges.any? do |disable_range|
+          disable_range.cover?(node_range) || node_range.cover?(disable_range)
+        end
       end
 
       private
 
       def end_position_for(node)
-        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        end_line = buffer.line_for_position(node.source_range.end_pos)
         buffer.line_range(end_line).end_pos
       end
 
@@ -46,17 +62,25 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
       def find_end_line(node)
-        if node.if_type? && node.loc.else
+        if node.if_type? && node.else?
           node.loc.else.line
-        elsif (next_sibling = node.right_sibling)
+        elsif node.if_type? && node.ternary?
+          node.else_branch.loc.line
+        elsif node.if_type? && node.elsif?
+          node.each_ancestor(:if).find(&:if?).loc.end.line
+        elsif node.block_type? || node.numblock_type?
+          node.loc.end.line
+        elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
-          parent.loc.end.line
+          parent.loc.respond_to?(:end) && parent.loc.end ? parent.loc.end.line : parent.loc.line
         else
           node.loc.end.line
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Lint/DuplicateBranch
     end
   end
 end

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

@@ -20,19 +20,30 @@ module RuboCop
         style_detected(possibilities)
       end
 
+      SYMBOL_TO_STRING_CACHE = Hash.new do |hash, key|
+        hash[key] = key.to_s if key.is_a?(Symbol)
+      end
+      private_constant :SYMBOL_TO_STRING_CACHE
+
+      # rubocop:disable Metrics
       def style_detected(detected)
         return if no_acceptable_style?
 
-        # `detected` can be a single style or an Array of possible styles
-        # (if there is more than one which matches the observed code)
-        detected_as_strings = Array(detected).map(&:to_s)
+        # This logic is more complex than it needs to be
+        # to avoid allocating Arrays in the hot code path.
+        updated_list =
+          if detected_style
+            if detected_style.size == 1 && detected_style.include?(SYMBOL_TO_STRING_CACHE[detected])
+              detected_style
+            else
+              detected_as_strings = SYMBOL_TO_STRING_CACHE.values_at(*detected)
+              detected_style & detected_as_strings
+            end
+          else
+            # We haven't observed any specific style yet.
+            SYMBOL_TO_STRING_CACHE.values_at(*detected)
+          end
 
-        updated_list = if detected_style
-                         detected_style & detected_as_strings
-                       else
-                         # We haven't observed any specific style yet.
-                         detected_as_strings
-                       end
         if updated_list.empty?
           no_acceptable_style!
         else
@@ -40,6 +51,7 @@ module RuboCop
           config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
+      # rubocop:enable Metrics
 
       def no_acceptable_style?
         config_to_allow_offenses['Enabled'] == false

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

@@ -5,8 +5,7 @@ module RuboCop
     # Common functionality for checking def nodes.
     module DefNode
       extend NodePattern::Macros
-
-      NON_PUBLIC_MODIFIERS = %w[private protected].freeze
+      include VisibilityHelp
 
       private
 
@@ -15,11 +14,7 @@ module RuboCop
       end
 
       def preceding_non_public_modifier?(node)
-        stripped_source_upto(node.first_line).any? { |line| NON_PUBLIC_MODIFIERS.include?(line) }
-      end
-
-      def stripped_source_upto(index)
-        processed_source[0..index].map(&:strip)
+        node_visibility(node) != :public
       end
 
       # @!method non_public_modifier?(node)

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

@@ -23,7 +23,7 @@ module RuboCop
       # The args node1 & node2 may represent a RuboCop::AST::Node
       # or a Parser::Source::Comment. Both respond to #loc.
       def preceding_comment?(node1, node2)
-        node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+        node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
       end
 
       # The args node1 & node2 may represent a RuboCop::AST::Node

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

@@ -29,7 +29,7 @@ module RuboCop
       # @param [Array] collection an array to return consecutive duplicates for
       # @return [Array] the consecutive duplicates
       def consecutive_duplicates(collection)
-        grouped_duplicates(collection).flat_map { |items| items[1..-1] }
+        grouped_duplicates(collection).flat_map { |items| items[1..] }
       end
 
       # Returns a hash of grouped duplicates. The key will be the first

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

@@ -6,7 +6,8 @@ module RuboCop
     #
     # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
     # Rails department has been extracted to RuboCop Rails gem.
-    # This module is deprecated and will be removed by RuboCop 2.0.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
     # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
     # with existing RuboCop Rails 2.8 or lower.
     #

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

@@ -7,12 +7,12 @@ module RuboCop
     module FirstElementLineBreak
       private
 
-      def check_method_line_break(node, children)
+      def check_method_line_break(node, children, ignore_last: false)
         return if children.empty?
 
         return unless method_uses_parens?(node, children.first)
 
-        check_children_line_break(node, children)
+        check_children_line_break(node, children, ignore_last: ignore_last)
       end
 
       def method_uses_parens?(node, limit)
@@ -20,7 +20,7 @@ module RuboCop
         /\s*\(\s*$/.match?(source)
       end
 
-      def check_children_line_break(node, children, start = node)
+      def check_children_line_break(node, children, start = node, ignore_last: false)
         return if children.empty?
 
         line = start.first_line
@@ -28,8 +28,8 @@ module RuboCop
         min = first_by_line(children)
         return if line != min.first_line
 
-        max = last_by_line(children)
-        return if line == max.last_line
+        max_line = last_line(children, ignore_last: ignore_last)
+        return if line == max_line
 
         add_offense(min) { |corrector| EmptyLineCorrector.insert_before(corrector, min) }
       end
@@ -38,8 +38,12 @@ module RuboCop
         nodes.min_by(&:first_line)
       end
 
-      def last_by_line(nodes)
-        nodes.max_by(&:last_line)
+      def last_line(nodes, ignore_last:)
+        if ignore_last
+          nodes.map(&:first_line)
+        else
+          nodes.map(&:last_line)
+        end.max
       end
     end
   end

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

@@ -69,6 +69,10 @@ module RuboCop
         end
       end
 
+      def leading_magic_comments
+        leading_comment_lines.map { |line| MagicComment.parse(line) }
+      end
+
       def leading_comment_lines
         first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
 

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def separator_delta(pair)
           if pair.hash_rocket?
-            correct_separator_column = pair.key.loc.expression.end.column + 1
+            correct_separator_column = pair.key.source_range.end.column + 1
             actual_separator_column = pair.loc.operator.column
 
             correct_separator_column - actual_separator_column