rubocop 0.78.0 → 1.13.0

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # 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 = {}
+          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,38 +5,73 @@ 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.'
 
-        def investigate(processed_source)
-          processed_source.each_comment do |comment|
-            next if comment.text !~ /\A(# *rubocop:((dis|en)able|todo) +)(.*)/
+        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 on_new_investigation
+          processed_source.comments.each do |comment|
+            next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
-            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
-              check_cop_name(name, comment, offset)
+
+            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
-          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
-                                                               nil, shall_warn)
-          ->(corrector) { corrector.replace(range, qualified_cop_name) }
-        end
-
         private
 
-        def check_cop_name(name, comment, offset)
-          return if name !~ /^[A-Z]/ || name =~ %r{/}
+        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)
+
+          add_offense(range) do |corrector|
+            cop_name = range.source
+            qualified_cop_name = Registry.global.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)
+          /\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.legacy_cop_names
+
+          legacy_cop_names.detect { |legacy_cop_name| legacy_cop_name.split('/')[1] == cop_name }
         end
       end
     end

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

@@ -12,8 +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']
       end
 
       def indentation(node)
@@ -25,30 +24,28 @@ module RuboCop
       end
 
       def check_alignment(items, base_column = nil)
-        unless items.empty?
-          base_column ||= display_column(items.first.source_range)
-        end
+        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 @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
 
+      # @api private
       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?
@@ -57,17 +54,27 @@ module RuboCop
         end
       end
 
+      # @api public
       def display_column(range)
         line = processed_source.lines[range.line - 1]
         Unicode::DisplayWidth.of(line[0, range.column])
       end
 
+      # @api public
       def within?(inner, outer)
         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)
-        processed_source.find_comment { |c| c.loc.line == line }
+        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

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

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

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

@@ -7,12 +7,14 @@ module RuboCop
       module AnnotationComment
         private
 
+        # @api public
         def annotation?(comment)
           _margin, first_word, colon, space, note = split_comment(comment)
           keyword_appearance?(first_word, colon, space) &&
             !just_first_word_of_sentence?(first_word, colon, space, note)
         end
 
+        # @api public
         def split_comment(comment)
           match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
           return false unless match
@@ -20,14 +22,17 @@ module RuboCop
           match.captures
         end
 
+        # @api public
         def keyword_appearance?(first_word, colon, space)
           first_word && keyword?(first_word.upcase) && (colon || space)
         end
 
+        # @api private
         def just_first_word_of_sentence?(first_word, colon, space, note)
           first_word == first_word.capitalize && !colon && space && note
         end
 
+        # @api public
         def keyword?(word)
           config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
         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
 
@@ -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/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

@@ -54,19 +54,26 @@ module RuboCop
 
       private
 
+      # @api private
       def extract_breakable_node_from_elements(node, elements, max)
         return unless breakable_collection?(node, elements)
         return if safe_to_ignore?(node)
 
         line = processed_source.lines[node.first_line - 1]
-        return if processed_source.commented?(node.loc.begin)
+        return if processed_source.line_with_comment?(node.loc.line)
         return if line.length <= max
 
         extract_first_element_over_column_limit(node, elements, max)
       end
 
+      # @api private
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
+
+        # If the first argument is a hash pair but the method is not parenthesized,
+        # the argument cannot be moved to another line because it cause a syntax error.
+        elements.shift if node.send_type? && !node.parenthesized? && elements.first.pair_type?
+
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
         return elements.first if i.zero?
@@ -74,10 +81,12 @@ module RuboCop
         elements[i - 1]
       end
 
+      # @api private
       def within_column_limit?(element, max, line)
-        element && element.loc.column < max && element.loc.line == line
+        element && element.loc.column <= max && element.loc.line == line
       end
 
+      # @api private
       def safe_to_ignore?(node)
         return true unless max
         return true if already_on_multiple_lines?(node)
@@ -88,19 +97,18 @@ module RuboCop
         # or redundant edits, we only mark one offense at a time.
         return true if contained_by_breakable_collection_on_same_line?(node)
 
-        if contained_by_multiline_collection_that_could_be_broken_up?(node)
-          return true
-        end
+        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
 
         false
       end
 
+      # @api private
       def breakable_collection?(node, elements)
         # For simplicity we only want to insert breaks in normal
         # hashes wrapped in a set of curly braces like {foo: 1}.
         # That is, not a kwargs hash. For method calls, this ensures
         # the method call is made with parens.
-        starts_with_bracket = node.loc.begin
+        starts_with_bracket = !node.hash_type? || node.loc.begin
 
         # If the call has a second argument, we can insert a line
         # break before the second argument and the rest of the
@@ -111,6 +119,7 @@ module RuboCop
         starts_with_bracket && has_second_element
       end
 
+      # @api private
       def contained_by_breakable_collection_on_same_line?(node)
         node.each_ancestor.find do |ancestor|
           # Ignore ancestors on different lines.
@@ -130,25 +139,24 @@ module RuboCop
         false
       end
 
+      # @api private
       def contained_by_multiline_collection_that_could_be_broken_up?(node)
         node.each_ancestor.find do |ancestor|
-          if ancestor.hash_type? || ancestor.array_type?
-            if breakable_collection?(ancestor, ancestor.children)
-              return children_could_be_broken_up?(ancestor.children)
-            end
+          if (ancestor.hash_type? || ancestor.array_type?) &&
+             breakable_collection?(ancestor, ancestor.children)
+            return children_could_be_broken_up?(ancestor.children)
           end
 
           next unless ancestor.send_type?
 
           args = process_args(ancestor.arguments)
-          if breakable_collection?(ancestor, args)
-            return children_could_be_broken_up?(args)
-          end
+          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
         end
 
         false
       end
 
+      # @api private
       def children_could_be_broken_up?(children)
         return false if all_on_same_line?(children)
 
@@ -161,12 +169,14 @@ module RuboCop
         false
       end
 
+      # @api private
       def all_on_same_line?(nodes)
         return true if nodes.empty?
 
         nodes.first.first_line == nodes.last.last_line
       end
 
+      # @api private
       def process_args(args)
         # If there is a trailing hash arg without explicit braces, like this:
         #
@@ -174,14 +184,12 @@ 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)
-          if last_arg.hash_type? && !last_arg.braces?
-            args = args.concat(args.pop.children)
-          end
-        end
+        last_arg = args.last
+        args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
         args
       end
 
+      # @api private
       def already_on_multiple_lines?(node)
         node.first_line != node.last_line
       end