rubocop-grantbirki 1.75.2

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative 'colorizable'
+
+module RuboCop
+  module Formatter
+    # A basic formatter that displays only files with offenses.
+    # Offenses are displayed at compact form - just the
+    # location of the problem and the associated message.
+    class SimpleTextFormatter < BaseFormatter
+      include Colorizable
+      include PathUtil
+
+      COLOR_FOR_SEVERITY = {
+        info:       :gray,
+        refactor:   :yellow,
+        convention: :yellow,
+        warning:    :magenta,
+        error:      :red,
+        fatal:      :red
+      }.freeze
+
+      def started(_target_files)
+        @total_offense_count = 0
+        @total_correction_count = 0
+        @total_correctable_count = 0
+      end
+
+      def file_finished(file, offenses)
+        return if offenses.empty?
+
+        count_stats(offenses)
+        report_file(file, offenses)
+      end
+
+      def finished(inspected_files)
+        report_summary(inspected_files.count,
+                       @total_offense_count,
+                       @total_correction_count,
+                       @total_correctable_count)
+      end
+
+      def report_file(file, offenses)
+        output.puts yellow("== #{smart_path(file)} ==")
+
+        offenses.each do |o|
+          output.printf(
+            "%<severity>s:%3<line>d:%3<column>d: %<message>s\n",
+            severity: colored_severity_code(o),
+            line: o.line,
+            column: o.real_column,
+            message: message(o)
+          )
+        end
+      end
+
+      def report_summary(file_count, offense_count, correction_count, correctable_count)
+        report = Report.new(file_count,
+                            offense_count,
+                            correction_count,
+                            correctable_count,
+                            rainbow,
+                            # :safe_autocorrect is a derived option based on several command-line
+                            # arguments - see RuboCop::Options#add_autocorrection_options
+                            safe_autocorrect: @options[:safe_autocorrect])
+
+        output.puts
+        output.puts report.summary
+      end
+
+      private
+
+      def count_stats(offenses)
+        @total_offense_count += offenses.count
+        corrected = offenses.count(&:corrected?)
+        @total_correction_count += corrected
+        @total_correctable_count += offenses.count(&:correctable?) - corrected
+      end
+
+      def colored_severity_code(offense)
+        color = COLOR_FOR_SEVERITY.fetch(offense.severity.name)
+        colorize(offense.severity.code, color)
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/m, yellow('\1'))
+      end
+
+      def message(offense)
+        message =
+          if offense.corrected_with_todo?
+            green('[Todo] ')
+          elsif offense.corrected?
+            green('[Corrected] ')
+          elsif offense.correctable?
+            yellow('[Correctable] ')
+          else
+            ''
+          end
+
+        "#{message}#{annotate_message(offense.message)}"
+      end
+
+      # A helper class for building the report summary text.
+      class Report
+        include Colorizable
+        include TextUtil
+
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(
+          file_count, offense_count, correction_count, correctable_count, rainbow,
+          safe_autocorrect: false
+        )
+          @file_count = file_count
+          @offense_count = offense_count
+          @correction_count = correction_count
+          @correctable_count = correctable_count
+          @rainbow = rainbow
+          @safe_autocorrect = safe_autocorrect
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def summary
+          if @correction_count.positive?
+            if @correctable_count.positive?
+              "#{files} inspected, #{offenses} detected, #{corrections} corrected, " \
+                "#{correctable}"
+            else
+              "#{files} inspected, #{offenses} detected, #{corrections} corrected"
+            end
+          elsif @correctable_count.positive?
+            "#{files} inspected, #{offenses} detected, #{correctable}"
+          else
+            "#{files} inspected, #{offenses} detected"
+          end
+        end
+
+        private
+
+        attr_reader :rainbow
+
+        def files
+          pluralize(@file_count, 'file')
+        end
+
+        def offenses
+          text = pluralize(@offense_count, 'offense', no_for_zero: true)
+          color = @offense_count.zero? ? :green : :red
+
+          colorize(text, color)
+        end
+
+        def corrections
+          text = pluralize(@correction_count, 'offense')
+          color = @correction_count == @offense_count ? :green : :cyan
+
+          colorize(text, color)
+        end
+
+        def correctable
+          if @safe_autocorrect
+            text = pluralize(@correctable_count, 'more offense')
+            "#{colorize(text, :yellow)} can be corrected with `rubocop -A`"
+          else
+            text = pluralize(@correctable_count, 'offense')
+            "#{colorize(text, :yellow)} autocorrectable"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/tap_formatter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter formats report data using the Test Anything Protocol.
+    # TAP allows for to communicate tests results in a language agnostics way.
+    class TapFormatter < ClangStyleFormatter
+      def started(target_files)
+        super
+        @progress_count = 1
+        output.puts "1..#{target_files.size}"
+      end
+
+      def file_finished(file, offenses)
+        if offenses.empty?
+          output.puts "ok #{@progress_count} - #{smart_path(file)}"
+        else
+          output.puts "not ok #{@progress_count} - #{smart_path(file)}"
+
+          count_stats(offenses)
+          report_file(file, offenses)
+        end
+
+        @progress_count += 1
+      end
+
+      private
+
+      def report_line(location)
+        source_line = location.source_line
+
+        if location.single_line?
+          output.puts("# #{source_line}")
+        else
+          output.puts("# #{source_line} #{yellow(ELLIPSES)}")
+        end
+      end
+
+      def report_highlighted_area(highlighted_area)
+        space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
+        source_area = highlighted_area.source
+        output.puts("# #{' ' * Unicode::DisplayWidth.of(space_area)}" \
+                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
+      end
+
+      def report_offense(file, 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)
+        )
+
+        return unless valid_line?(offense)
+
+        report_line(offense.location)
+        report_highlighted_area(offense.highlighted_area)
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/, '\1')
+      end
+
+      def message(offense)
+        message =
+          if offense.corrected_with_todo?
+            '[Todo] '
+          elsif offense.corrected?
+            '[Corrected] '
+          elsif offense.correctable?
+            '[Correctable] '
+          else
+            ''
+          end
+
+        "#{message}#{annotate_message(offense.message)}"
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/text_util.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # Common logic for UI texts.
+    module TextUtil
+      module_function
+
+      def pluralize(number, thing, options = {})
+        if number.zero? && options[:no_for_zero]
+          "no #{thing}s"
+        elsif number == 1
+          "1 #{thing}"
+        else
+          "#{number} #{thing}s"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Formatter
+    # This formatter displays the list of offensive files, sorted by number of
+    # offenses with the worst offenders first.
+    #
+    # Here's the format:
+    #
+    # 26  this/file/is/really/bad.rb
+    # 3   just/ok.rb
+    # --
+    # 29  Total in 2 files
+    class WorstOffendersFormatter < BaseFormatter
+      attr_reader :offense_counts
+
+      def started(target_files)
+        super
+        @offense_counts = {}
+      end
+
+      def file_finished(file, offenses)
+        return if offenses.empty?
+
+        path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+        @offense_counts[path] = offenses.size
+      end
+
+      def finished(_inspected_files)
+        report_summary(@offense_counts)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def report_summary(offense_counts)
+        per_file_counts = ordered_offense_counts(offense_counts)
+        total_count = total_offense_count(offense_counts)
+        file_count = per_file_counts.size
+
+        output.puts
+
+        column_width = total_count.to_s.length + 2
+        per_file_counts.each do |file_name, count|
+          output.puts "#{count.to_s.ljust(column_width)}#{file_name}\n"
+        end
+
+        output.puts '--'
+        output.puts "#{total_count}  Total in #{file_count} files"
+
+        output.puts
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def ordered_offense_counts(offense_counts)
+        offense_counts.sort_by { |k, v| [-v, k] }.to_h
+      end
+
+      def total_offense_count(offense_counts)
+        offense_counts.values.sum
+      end
+    end
+  end
+end

data/lib/rubocop/formatter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The bootstrap module for formatter.
+  module Formatter
+    require_relative 'formatter/text_util'
+
+    require_relative 'formatter/base_formatter'
+    require_relative 'formatter/simple_text_formatter'
+
+    # relies on simple text
+    require_relative 'formatter/clang_style_formatter'
+    require_relative 'formatter/disabled_config_formatter'
+    require_relative 'formatter/emacs_style_formatter'
+    require_relative 'formatter/file_list_formatter'
+    require_relative 'formatter/fuubar_style_formatter'
+    require_relative 'formatter/github_actions_formatter'
+    require_relative 'formatter/html_formatter'
+    require_relative 'formatter/json_formatter'
+    require_relative 'formatter/junit_formatter'
+    require_relative 'formatter/markdown_formatter'
+    require_relative 'formatter/offense_count_formatter'
+    require_relative 'formatter/pacman_formatter'
+    require_relative 'formatter/progress_formatter'
+    require_relative 'formatter/quiet_formatter'
+    require_relative 'formatter/tap_formatter'
+    require_relative 'formatter/worst_offenders_formatter'
+
+    # relies on progress formatter
+    require_relative 'formatter/auto_gen_config_formatter'
+
+    require_relative 'formatter/formatter_set'
+  end
+end

data/lib/rubocop/lockfile.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+begin
+  # We might not be running with `bundle exec`, so we need to pull in Bundler ourselves,
+  # in order to use `Bundler::LockfileParser`.
+  require 'bundler'
+rescue LoadError
+  nil
+end
+
+module RuboCop
+  # Encapsulation of a lockfile for use when checking for gems.
+  # Does not actually resolve gems, just parses the lockfile.
+  # @api private
+  class Lockfile
+    # @param [String, Pathname, nil] lockfile_path
+    def initialize(lockfile_path = nil)
+      lockfile_path ||= begin
+        ::Bundler.default_lockfile if use_bundler_lock_parser?
+      rescue ::Bundler::GemfileNotFound
+        nil # We might not be a folder with a Gemfile, but that's okay.
+      end
+
+      @lockfile_path = lockfile_path
+    end
+
+    # Gems that the bundle directly depends on.
+    # @return [Array<Bundler::Dependency>, nil]
+    def dependencies
+      return [] unless parser
+
+      parser.dependencies.values
+    end
+
+    # All activated gems, including transitive dependencies.
+    # @return [Array<Bundler::Dependency>, nil]
+    def gems
+      return [] unless parser
+
+      # `Bundler::LockfileParser` returns `Bundler::LazySpecification` objects
+      # which are not resolved, so extract the dependencies from them
+      parser.dependencies.values.concat(parser.specs.flat_map(&:dependencies))
+    end
+
+    # Returns the locked versions of gems from this lockfile.
+    # @param [Boolean] include_transitive_dependencies: When false, only direct dependencies
+    #   are returned, i.e. those listed explicitly in the `Gemfile`.
+    # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names.
+    def gem_versions(include_transitive_dependencies: true)
+      return {} unless parser
+
+      all_gem_versions = parser.specs.to_h { |spec| [spec.name, spec.version] }
+
+      if include_transitive_dependencies
+        all_gem_versions
+      else
+        direct_dep_names = parser.dependencies.keys
+        all_gem_versions.slice(*direct_dep_names)
+      end
+    end
+
+    # Whether this lockfile includes the named gem, directly or indirectly.
+    # @param [String] name
+    # @return [Boolean]
+    def includes_gem?(name)
+      gems.any? { |gem| gem.name == name }
+    end
+
+    private
+
+    # @return [Bundler::LockfileParser, nil]
+    def parser
+      return @parser if defined?(@parser)
+
+      @parser = if @lockfile_path && File.exist?(@lockfile_path) && use_bundler_lock_parser?
+                  begin
+                    lockfile = ::Bundler.read_file(@lockfile_path)
+                    ::Bundler::LockfileParser.new(lockfile) if lockfile
+                  rescue ::Bundler::BundlerError
+                    nil
+                  end
+                end
+    end
+
+    def use_bundler_lock_parser?
+      return false unless Object.const_defined?(:Bundler)
+
+      Bundler.const_defined?(:LockfileParser) && Bundler::VERSION >= '2.0'
+    end
+  end
+end

data/lib/rubocop/lsp/diagnostic.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Diagnostic for Language Server Protocol of RuboCop.
+    # @api private
+    class Diagnostic
+      def initialize(document_encoding, offense, uri, cop_class)
+        @document_encoding = document_encoding
+        @offense = offense
+        @uri = uri
+        @cop_class = cop_class
+      end
+
+      def to_lsp_code_actions
+        code_actions = []
+
+        code_actions << autocorrect_action if correctable?
+        code_actions << disable_line_action
+
+        code_actions
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def to_lsp_diagnostic(config)
+        highlighted = @offense.highlighted_area
+
+        LanguageServer::Protocol::Interface::Diagnostic.new(
+          message: message,
+          source: 'RuboCop',
+          code: @offense.cop_name,
+          code_description: code_description(config),
+          severity: severity,
+          range: LanguageServer::Protocol::Interface::Range.new(
+            start: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.begin_pos
+            ),
+            end: LanguageServer::Protocol::Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.end_pos
+            )
+          ),
+          data: {
+            correctable: correctable?,
+            code_actions: to_lsp_code_actions
+          }
+        )
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def message
+        message = @offense.message
+        message += "\n\nThis offense is not autocorrectable.\n" unless correctable?
+        message
+      end
+
+      def severity
+        Severity.find_by(@offense.severity.name)
+      end
+
+      def code_description(config)
+        return unless @cop_class
+        return unless (doc_url = @cop_class.documentation_url(config))
+
+        LanguageServer::Protocol::Interface::CodeDescription.new(href: doc_url)
+      end
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def autocorrect_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Autocorrect #{@offense.cop_name}",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: correctable? ? offense_replacements : []
+              )
+            ]
+          ),
+          is_preferred: true
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      # rubocop:disable Metrics/MethodLength
+      def offense_replacements
+        @offense.corrector.as_replacements.map do |range, replacement|
+          LanguageServer::Protocol::Interface::TextEdit.new(
+            range: LanguageServer::Protocol::Interface::Range.new(
+              start: LanguageServer::Protocol::Interface::Position.new(
+                line: range.line - 1,
+                character: range.column
+              ),
+              end: LanguageServer::Protocol::Interface::Position.new(
+                line: range.last_line - 1,
+                character: range.last_column
+              )
+            ),
+            new_text: replacement
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def disable_line_action
+        LanguageServer::Protocol::Interface::CodeAction.new(
+          title: "Disable #{@offense.cop_name} for this line",
+          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
+          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            document_changes: [
+              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
+                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: line_disable_comment
+              )
+            ]
+          )
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      def line_disable_comment
+        new_text = if @offense.source_line.include?(' # rubocop:disable ')
+                     ",#{@offense.cop_name}"
+                   else
+                     " # rubocop:disable #{@offense.cop_name}"
+                   end
+
+        eol = LanguageServer::Protocol::Interface::Position.new(
+          line: @offense.line - 1,
+          character: length_of_line(@offense.source_line)
+        )
+
+        # TODO: fails for multiline strings - may be preferable to use block
+        # comments to disable some offenses
+        inline_comment = LanguageServer::Protocol::Interface::TextEdit.new(
+          range: LanguageServer::Protocol::Interface::Range.new(start: eol, end: eol),
+          new_text: new_text
+        )
+
+        [inline_comment]
+      end
+
+      def length_of_line(line)
+        if @document_encoding == Encoding::UTF_16LE
+          line_length = 0
+          line.codepoints.each do |codepoint|
+            line_length += 1
+            line_length += 1 if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+          end
+          line_length
+        else
+          line.length
+        end
+      end
+
+      def correctable?
+        !@offense.corrector.nil?
+      end
+
+      def ensure_uri_scheme(uri)
+        uri = URI.parse(uri)
+        uri.scheme = 'file' if uri.scheme.nil?
+        uri
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Log for Language Server Protocol of RuboCop.
+    # @api private
+    class Logger
+      def self.log(message, prefix: '[server]')
+        warn("#{prefix} #{message}")
+      end
+    end
+  end
+end