rubocop 0.71.0 → 0.75.1

data/lib/rubocop/cop/team.rb

@@ -81,6 +81,9 @@ module RuboCop
           File.open(filename, 'w') { |f| f.write(new_source) }
         end
         @updated_source_file = true
+      rescue RuboCop::ErrorWithAnalyzedFileLocation => e
+        process_errors(buffer.name, [e])
+        raise e.cause
       end
 
       private
@@ -103,8 +106,8 @@ module RuboCop
 
         other = investigate(other_cops, processed_source)
 
-        errors = autocorrect.errors.merge(other.errors)
-        process_commissioner_errors(processed_source.path, errors)
+        errors = [*autocorrect.errors, *other.errors]
+        process_errors(processed_source.path, errors)
 
         autocorrect.offenses.concat(other.offenses)
       end
@@ -149,19 +152,17 @@ module RuboCop
         end
       end
 
-      def process_commissioner_errors(file, file_errors)
-        file_errors.each do |cop, errors|
-          errors.each do |cop_error|
-            e = cop_error.error
-            line = ":#{cop_error.line}" if cop_error.line
-            column = ":#{cop_error.column}" if cop_error.column
-            location = "#{file}#{line}#{column}"
+      def process_errors(file, errors)
+        errors.each do |error|
+          line = ":#{error.line}" if error.line
+          column = ":#{error.column}" if error.column
+          location = "#{file}#{line}#{column}"
+          cause = error.cause
 
-            if e.is_a?(Warning)
-              handle_warning(e, location)
-            else
-              handle_error(e, location, cop)
-            end
+          if cause.is_a?(Warning)
+            handle_warning(cause, location)
+          else
+            handle_error(cause, location, error.cop)
           end
         end
       end

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

@@ -0,0 +1,128 @@
+# 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(string, **opts)
+            @source = string
+            @begin_pos = opts[:begin_pos]
+            @end_pos = opts[:end_pos]
+            @flags = opts[:flags]
+            @width = opts[:width]
+            @precision = opts[:precision]
+            @name = opts[:name]
+            @type = opts[: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
+            match = Regexp.last_match
+            FormatSequence.new(
+              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
+        end
+      end
+    end
+  end
+end

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

@@ -8,4 +8,27 @@ module RuboCop
   class Error < StandardError; end
 
   class ValidationError < Error; end
+
+  # A wrapper to display errored location of analyzed file.
+  class ErrorWithAnalyzedFileLocation < Error
+    def initialize(cause:, node:, cop:)
+      @cause = cause
+      @cop = cop
+      @location = node.is_a?(RuboCop::AST::Node) ? node.loc : node
+    end
+
+    attr_reader :cause, :cop
+
+    def line
+      @location&.line
+    end
+
+    def column
+      @location&.column
+    end
+
+    def message
+      "cause: #{cause.inspect}"
+    end
+  end
 end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -15,9 +15,14 @@ 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

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