rubocop 0.73.0 → 0.77.0

data/lib/rubocop/cop/style/variable_interpolation.rb

@@ -16,19 +16,15 @@ module RuboCop
       #   /check #{$pattern}/
       #   "Let's go to the #{@store}"
       class VariableInterpolation < Cop
+        include Interpolation
+
         MSG = 'Replace interpolated variable `%<variable>s` ' \
               'with expression `#{%<variable>s}`.'
 
-        def on_dstr(node)
-          check_for_interpolation(node)
-        end
-
-        def on_regexp(node)
-          check_for_interpolation(node)
-        end
-
-        def on_xstr(node)
-          check_for_interpolation(node)
+        def on_node_with_interpolations(node)
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node)
+          end
         end
 
         def autocorrect(node)
@@ -39,12 +35,6 @@ module RuboCop
 
         private
 
-        def check_for_interpolation(node)
-          var_nodes(node.children).each do |var_node|
-            add_offense(var_node)
-          end
-        end
-
         def message(node)
           format(MSG, variable: node.source)
         end

data/lib/rubocop/cop/team.rb

@@ -86,6 +86,11 @@ module RuboCop
         raise e.cause
       end
 
+      def external_dependency_checksum
+        keys = cops.map(&:external_dependency_checksum).compact
+        Digest::SHA1.hexdigest(keys.join)
+      end
+
       private
 
       def offenses(processed_source)

data/lib/rubocop/cop/util.rb

@@ -9,7 +9,7 @@ module RuboCop
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
       LITERAL_REGEX =
-        /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/.freeze
+        %r{[\w\s\-,"'!#%&<>=;:`~/]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]}.freeze
 
       module_function
 

data/lib/rubocop/cop/utils/format_string.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Utils
+      # Parses {Kernel#sprintf} format strings.
+      class FormatString
+        DIGIT_DOLLAR  = /(\d+)\$/.freeze
+        FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
+        NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
+        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
+        WIDTH         = /(?<width>#{NUMBER})/.freeze
+        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
+        TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
+        NAME          = /<(?<name>\w+)>/.freeze
+        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
+
+        SEQUENCE = /
+            % (?<type>%)
+          | % (?<flags>#{FLAG}*)
+            (?:
+              (?: #{WIDTH}? #{PRECISION}? #{NAME}?
+                | #{WIDTH}? #{NAME} #{PRECISION}?
+                | #{NAME} (?<more_flags>#{FLAG}*) #{WIDTH}? #{PRECISION}?
+              ) #{TYPE}
+              | #{WIDTH}? #{PRECISION}? #{TEMPLATE_NAME}
+            )
+        /x.freeze
+
+        # The syntax of a format sequence is as follows.
+        #
+        # ```
+        # %[flags][width][.precision]type
+        # ```
+        #
+        # A format sequence consists of a percent sign, followed by optional
+        # flags, width, and precision indicators, then terminated with a field
+        # type character.
+        #
+        # For more complex formatting, Ruby supports a reference by name.
+        #
+        # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
+        class FormatSequence
+          attr_reader :begin_pos, :end_pos
+          attr_reader :flags, :width, :precision, :name, :type
+
+          def initialize(match)
+            @source = match[0]
+            @begin_pos = match.begin(0)
+            @end_pos = match.end(0)
+            @flags = match[:flags].to_s + match[:more_flags].to_s
+            @width = match[:width]
+            @precision = match[:precision]
+            @name = match[:name]
+            @type = match[:type]
+          end
+
+          def percent?
+            type == '%'
+          end
+
+          def annotated?
+            name && @source.include?('<')
+          end
+
+          def template?
+            name && @source.include?('{')
+          end
+
+          # Number of arguments required for the format sequence
+          def arity
+            @source.scan('*').count + 1
+          end
+
+          def max_digit_dollar_num
+            @source.scan(DIGIT_DOLLAR).map do |(digit_dollar_num)|
+              digit_dollar_num.to_i
+            end.max
+          end
+
+          def style
+            if annotated?
+              :annotated
+            elsif template?
+              :template
+            else
+              :unannotated
+            end
+          end
+        end
+
+        def initialize(string)
+          @source = string
+        end
+
+        def format_sequences
+          @format_sequences ||= parse
+        end
+
+        def named_interpolation?
+          format_sequences.any?(&:name)
+        end
+
+        def max_digit_dollar_num
+          format_sequences.map(&:max_digit_dollar_num).max
+        end
+
+        private
+
+        def parse
+          @source.to_enum(:scan, SEQUENCE).map do
+            FormatSequence.new(
+              Regexp.last_match
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_force.rb

@@ -284,11 +284,7 @@ module RuboCop
       def process_scope(node)
         if TWISTED_SCOPE_TYPES.include?(node.type)
           # See the comment at the end of file for this behavior.
-          twisted_nodes = [node.children[0]]
-          twisted_nodes << node.children[1] if node.class_type?
-          twisted_nodes.compact!
-
-          twisted_nodes.each do |twisted_node|
+          twisted_nodes(node).each do |twisted_node|
             process_node(twisted_node)
             scanned_nodes << twisted_node
           end
@@ -298,6 +294,12 @@ module RuboCop
         skip_children!
       end
 
+      def twisted_nodes(node)
+        twisted_nodes = [node.children[0]]
+        twisted_nodes << node.children[1] if node.class_type?
+        twisted_nodes.compact
+      end
+
       def process_send(node)
         _receiver, method_name, args = *node
         return unless method_name == :binding

data/lib/rubocop/cop/variable_force/variable.rb

@@ -37,7 +37,7 @@ module RuboCop
           !@references.empty?
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
@@ -50,6 +50,13 @@ module RuboCop
               assignment.reference!(node)
             end
 
+            # Modifier if/unless conditions are special. Assignments made in
+            # them do not put the assigned variable in scope to the left of the
+            # if/unless keyword. A preceding assignment is needed to put the
+            # variable in scope. For this reason we skip to the next assignment
+            # here.
+            next if in_modifier_if?(assignment)
+
             break if !assignment.branch || assignment.branch == reference.branch
 
             unless assignment.branch.may_run_incompletely?
@@ -57,7 +64,13 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def in_modifier_if?(assignment)
+          parent = assignment.node.parent
+          parent = parent.parent if parent&.begin_type?
+          parent&.if_type? && parent&.modifier_form?
+        end
 
         def capture_with_block!
           @captured_by_block = true

data/lib/rubocop/core_ext/string.rb

@@ -20,28 +20,4 @@ class String
       empty? || strip.empty?
     end
   end
-
-  unless method_defined? :strip_indent
-    # The method strips the whitespace preceding the base indentation.
-    # Useful for HEREDOCs and other multi-line strings.
-    #
-    # @example
-    #
-    #   code = <<~END
-    #     def test
-    #       some_method
-    #       other_method
-    #     end
-    #   END
-    #
-    #   #=> "def\n  some_method\n  \nother_method\nend"
-    #
-    # @todo Replace call sites with squiggly heredocs when required Ruby
-    #   version is >= 2.3.0
-    def strip_indent
-      leading_space = scan(/^[ \t]*(?=\S)/).min
-      indent = leading_space ? leading_space.size : 0
-      gsub(/^[ \t]{#{indent}}/, '')
-    end
-  end
 end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -15,20 +15,23 @@ module RuboCop
       private
 
       def report_offense(file, offense)
-        output.printf("%s:%d:%d: %s: %s\n",
-                      cyan(smart_path(file)), offense.line, offense.real_column,
-                      colored_severity_code(offense), message(offense))
+        output.printf(
+          "%<path>s:%<line>d:%<column>d: %<severity>s: %<message>s\n",
+          path: cyan(smart_path(file)),
+          line: offense.line,
+          column: offense.real_column,
+          severity: colored_severity_code(offense),
+          message: message(offense)
+        )
 
-        # rubocop:disable Lint/HandleExceptions
         begin
           return unless valid_line?(offense)
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
+        rescue IndexError # rubocop:disable Lint/SuppressedException
           # range is not on a valid line; perhaps the source file is empty
         end
-        # rubocop:enable Lint/HandleExceptions
       end
 
       def valid_line?(offense)

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -8,17 +8,30 @@ module RuboCop
     class EmacsStyleFormatter < BaseFormatter
       def file_finished(file, offenses)
         offenses.each do |o|
-          message = if o.corrected?
-                      "[Corrected] #{o.message}"
-                    else
-                      o.message
-                    end
-
-          output.printf("%s:%d:%d: %s: %s\n",
-                        file, o.line, o.real_column, o.severity.code,
-                        message.tr("\n", ' '))
+          output.printf(
+            "%<path>s:%<line>d:%<column>d: %<severity>s: %<message>s\n",
+            path: file,
+            line: o.line,
+            column: o.real_column,
+            severity: o.severity.code,
+            message: message(o)
+          )
         end
       end
+
+      private
+
+      def message(offense)
+        message =
+          if offense.corrected_with_todo?
+            "[Todo] #{offense.message}"
+          elsif offense.corrected?
+            "[Corrected] #{offense.message}"
+          else
+            offense.message
+          end
+        message.tr("\n", ' ')
+      end
     end
   end
 end

data/lib/rubocop/formatter/file_list_formatter.rb

@@ -13,7 +13,7 @@ module RuboCop
       def file_finished(file, offenses)
         return if offenses.empty?
 
-        output.printf("%s\n", file)
+        output.printf("%<path>s\n", path: file)
       end
     end
   end

data/lib/rubocop/formatter/formatter_set.rb

@@ -9,20 +9,21 @@ module RuboCop
     # which invoke same method of each formatters.
     class FormatterSet < Array
       BUILTIN_FORMATTERS_FOR_KEYS = {
-        'progress'    => ProgressFormatter,
-        'simple'      => SimpleTextFormatter,
-        'clang'       => ClangStyleFormatter,
-        'fuubar'      => FuubarStyleFormatter,
-        'emacs'       => EmacsStyleFormatter,
-        'json'        => JSONFormatter,
-        'html'        => HTMLFormatter,
-        'files'       => FileListFormatter,
-        'offenses'    => OffenseCountFormatter,
-        'disabled'    => DisabledLinesFormatter,
-        'worst'       => WorstOffendersFormatter,
-        'tap'         => TapFormatter,
-        'quiet'       => QuietFormatter,
-        'autogenconf' => AutoGenConfigFormatter
+        '[a]utogenconf' => AutoGenConfigFormatter,
+        '[c]lang'       => ClangStyleFormatter,
+        '[d]isabled'    => DisabledLinesFormatter,
+        '[e]macs'       => EmacsStyleFormatter,
+        '[fi]les'       => FileListFormatter,
+        '[fu]ubar'      => FuubarStyleFormatter,
+        '[h]tml'        => HTMLFormatter,
+        '[j]son'        => JSONFormatter,
+        '[o]ffenses'    => OffenseCountFormatter,
+        '[pa]cman'      => PacmanFormatter,
+        '[p]rogress'    => ProgressFormatter,
+        '[q]uiet'       => QuietFormatter,
+        '[s]imple'      => SimpleTextFormatter,
+        '[t]ap'         => TapFormatter,
+        '[w]orst'       => WorstOffendersFormatter
       }.freeze
 
       FORMATTER_APIS = %i[started finished].freeze
@@ -81,7 +82,7 @@ module RuboCop
 
       def builtin_formatter_class(specified_key)
         matching_keys = BUILTIN_FORMATTERS_FOR_KEYS.keys.select do |key|
-          key.start_with?(specified_key)
+          key =~ /^\[#{specified_key}\]/ || specified_key == key.delete('[]')
         end
 
         raise %(No formatter for "#{specified_key}") if matching_keys.empty?

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter prints a PACDOT per every file to be analyzed.
+    # Pacman will "eat" one PACDOT per file when no offense is detected.
+    # Otherwise it will print a Ghost.
+    # This is inspired by the Pacman formatter for RSpec by Carlos Rojas.
+    # https://github.com/go-labs/rspec_pacman_formatter
+    class PacmanFormatter < ClangStyleFormatter
+      include TextUtil
+      attr_accessor :progress_line
+
+      FALLBACK_TERMINAL_WIDTH = 80
+      GHOST = 'ᗣ'
+      PACMAN = Rainbow('ᗧ').yellow.bright
+      PACDOT = Rainbow('•').yellow.bright
+
+      def initialize(output, options = {})
+        super
+        @progress_line = ''
+        @total_files   = 0
+        @repetitions   = 0
+      end
+
+      def started(target_files)
+        super
+        @total_files = target_files.size
+        output.puts "Eating #{pluralize(target_files.size, 'file')}"
+        update_progress_line
+      end
+
+      def file_started(_file, _options)
+        step(PACMAN)
+      end
+
+      def file_finished(file, offenses)
+        count_stats(offenses) unless offenses.empty?
+        next_step(offenses)
+        report_file(file, offenses)
+      end
+
+      def next_step(offenses)
+        return step('.') if offenses.empty?
+
+        ghost_color = COLOR_FOR_SEVERITY[offenses.last.severity.name]
+        step(colorize(GHOST, ghost_color))
+      end
+
+      def cols
+        @cols ||= begin
+          _height, width = $stdout.winsize
+          width.nil? || width.zero? ? FALLBACK_TERMINAL_WIDTH : width
+        end
+      end
+
+      def update_progress_line
+        return pacdots(@total_files) unless @total_files > cols
+        return pacdots(cols) unless (@total_files / cols).eql?(@repetitions)
+
+        pacdots((@total_files - (cols * @repetitions)))
+      end
+
+      def pacdots(number)
+        @progress_line = PACDOT * number
+      end
+
+      def step(character)
+        regex = /#{Regexp.quote(PACMAN)}|#{Regexp.quote(PACDOT)}/
+        @progress_line = @progress_line.sub(regex, character)
+        output.printf("%<line>s\r", line: @progress_line)
+        return unless @progress_line[-1] =~ /ᗣ|\./
+
+        @repetitions += 1
+        output.puts
+        update_progress_line
+      end
+    end
+  end
+end