super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cli/command/suggest_extensions.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Suggest RuboCop extensions to install based on Gemfile dependencies.
+      # Only primary dependencies are evaluated, so if a dependency depends on a
+      # gem with an extension, it is not suggested. However, if an extension is
+      # a transitive dependency, it will not be suggested.
+      # @api private
+      class SuggestExtensions < Base
+        # Combination of short and long formatter names.
+        INCLUDED_FORMATTERS = %w[p progress fu fuubar pa pacman].freeze
+
+        self.command_name = :suggest_extensions
+
+        def run
+          return if skip? || extensions.none?
+
+          print_install_suggestions if not_installed_extensions.any?
+          print_load_suggestions if installed_and_not_loaded_extensions.any?
+
+          print_opt_out_instruction
+
+          puts if @options[:display_time]
+        end
+
+        private
+
+        def skip?
+          # Disable outputting the notification:
+          # 1. On CI
+          # 2. When given RuboCop options that it doesn't make sense for
+          # 3. For all formatters except specified in `INCLUDED_FORMATTERS'`
+          ENV.fetch('CI', nil) ||
+            @options[:only] || @options[:debug] || @options[:list_target_files] ||
+            @options[:out] || @options[:stdin] ||
+            !INCLUDED_FORMATTERS.include?(current_formatter)
+        end
+
+        def print_install_suggestions
+          puts
+          puts 'Tip: Based on detected gems, the following ' \
+               'RuboCop extension libraries might be helpful:'
+
+          not_installed_extensions.sort.each do |extension|
+            puts "  * #{extension} (https://rubygems.org/gems/#{extension})"
+          end
+        end
+
+        def print_load_suggestions
+          puts
+          puts 'The following RuboCop extension libraries are installed but not loaded in config:'
+
+          installed_and_not_loaded_extensions.sort.each do |extension|
+            puts "  * #{extension}"
+          end
+        end
+
+        def print_opt_out_instruction
+          puts
+          puts 'You can opt out of this message by adding the following to your config ' \
+               '(see https://docs.rubocop.org/rubocop/plugins.html#plugin-suggestions ' \
+               'for more options):'
+          puts '  AllCops:'
+          puts '    SuggestExtensions: false'
+        end
+
+        def current_formatter
+          @options[:format] || @config_store.for_pwd.for_all_cops['DefaultFormatter'] || 'p'
+        end
+
+        def all_extensions
+          return [] unless lockfile.dependencies.any?
+
+          extensions = @config_store.for_pwd.for_all_cops['SuggestExtensions']
+          case extensions
+          when true
+            extensions = ConfigLoader.default_configuration.for_all_cops['SuggestExtensions']
+          when false, nil
+            extensions = {}
+          end
+
+          extensions.select { |_, v| (Array(v) & dependent_gems).any? }.keys
+        end
+
+        def extensions
+          not_installed_extensions + installed_and_not_loaded_extensions
+        end
+
+        def installed_extensions
+          all_extensions & installed_gems
+        end
+
+        def not_installed_extensions
+          all_extensions - installed_gems
+        end
+
+        def loaded_extensions
+          rubocop_config = @config_store.for_pwd
+
+          plugin_names = rubocop_config.loaded_plugins.map do |plugin|
+            plugin.about.name
+          end
+
+          plugin_names + rubocop_config.loaded_features.to_a
+        end
+
+        def installed_and_not_loaded_extensions
+          installed_extensions - loaded_extensions
+        end
+
+        def lockfile
+          @lockfile ||= Lockfile.new
+        end
+
+        def dependent_gems
+          lockfile.dependencies.map(&:name)
+        end
+
+        def installed_gems
+          lockfile.gems.map(&:name)
+        end
+
+        def puts(*args)
+          output = (@options[:stderr] ? $stderr : $stdout)
+          output.puts(*args)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cli/command/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Display version.
+      # @api private
+      class Version < Base
+        self.command_name = :version
+
+        def run
+          puts RuboCop::Version::STRING if @options[:version]
+          puts RuboCop::Version.verbose(env: env) if @options[:verbose_version]
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cli/command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    # Home of subcommands in the CLI.
+    # @api private
+    module Command
+      class << self
+        # Find the command with a given name and run it in an environment.
+        def run(env, name)
+          class_for(name).new(env).run
+        end
+
+        private
+
+        def class_for(name)
+          Base.by_command_name(name)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cli/environment.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    # Execution environment for a CLI command.
+    # @api private
+    class Environment
+      attr_reader :options, :config_store, :paths
+
+      def initialize(options, config_store, paths)
+        @options = options
+        @config_store = config_store
+        @paths = paths
+      end
+
+      # Run a command in this environment.
+      def run(name)
+        Command.run(self, name)
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cli.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RuboCop
+  # The CLI is a class responsible of handling all the command line interface
+  # logic.
+  class CLI
+    STATUS_SUCCESS     = 0
+    STATUS_OFFENSES    = 1
+    STATUS_ERROR       = 2
+    STATUS_INTERRUPTED = Signal.list['INT'] + 128
+    DEFAULT_PARALLEL_OPTIONS = %i[
+      color config debug display_style_guide display_time display_only_fail_level_offenses
+      display_only_failed editor_mode except extra_details fail_level fix_layout format formatters
+      ignore_disable_comments lint only only_guide_cops out require safe
+      autocorrect safe_autocorrect autocorrect_all
+    ].freeze
+
+    class Finished < StandardError; end
+
+    attr_reader :options, :config_store
+
+    def initialize
+      @options = {}
+      @config_store = ConfigStore.new
+    end
+
+    # @api public
+    #
+    # Entry point for the application logic. Here we
+    # do the command line arguments processing and inspect
+    # the target files.
+    #
+    # @param args [Array<String>] command line arguments
+    # @return [Integer] UNIX exit code
+    #
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def run(args = ARGV)
+      time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      @options, paths = Options.new.parse(args)
+      @env = Environment.new(@options, @config_store, paths)
+
+      profile_if_needed do
+        if @options[:init]
+          run_command(:init)
+        else
+          act_on_options
+          validate_options_vs_config
+          parallel_by_default!
+          apply_default_formatter
+          report_pending_cops
+          execute_runners
+        end
+      end
+    rescue ConfigNotFoundError, IncorrectCopNameError, OptionArgumentError => e
+      warn Rainbow(e.message).red
+      STATUS_ERROR
+    rescue RuboCop::Error => e
+      warn Rainbow("Error: #{e.message}").red
+      STATUS_ERROR
+    rescue Interrupt
+      warn ''
+      warn 'Exiting...'
+      STATUS_INTERRUPTED
+    rescue Finished
+      STATUS_SUCCESS
+    rescue OptionParser::ParseError => e
+      warn e.message
+      warn 'For usage information, use --help'
+      STATUS_ERROR
+    rescue StandardError, SyntaxError, LoadError => e
+      warn e.message
+      warn e.backtrace
+      STATUS_ERROR
+    ensure
+      elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+      if @options[:debug] || @options[:display_time]
+        puts "Finished in #{elapsed_time.round(5)} seconds"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    private
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def profile_if_needed
+      return yield unless @options[:profile]
+
+      return STATUS_ERROR unless require_gem('stackprof')
+
+      with_memory = @options[:memory]
+      if with_memory
+        return STATUS_ERROR unless require_gem('memory_profiler')
+
+        MemoryProfiler.start
+      end
+
+      tmp_dir = File.join(ConfigFinder.project_root, 'tmp')
+      FileUtils.mkdir_p(tmp_dir)
+      cpu_profile_file = File.join(tmp_dir, 'rubocop-stackprof.dump')
+      status = nil
+
+      StackProf.run(out: cpu_profile_file) do
+        status = yield
+      end
+      puts "Profile report generated at #{cpu_profile_file}"
+
+      if with_memory
+        puts 'Building memory report...'
+        report = MemoryProfiler.stop
+        memory_profile_file = File.join(tmp_dir, 'rubocop-memory_profiler.txt')
+        report.pretty_print(to_file: memory_profile_file, scale_bytes: true)
+        puts "Memory report generated at #{memory_profile_file}"
+      end
+      status
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def require_gem(name)
+      require name
+      true
+    rescue LoadError
+      warn("You don't have #{name} installed. Add it to your Gemfile and run `bundle install`")
+      false
+    end
+
+    def run_command(name)
+      @env.run(name)
+    end
+
+    def execute_runners
+      if @options[:auto_gen_config]
+        run_command(:auto_gen_config)
+      else
+        run_command(:execute_runner).tap { suggest_extensions }
+      end
+    end
+
+    def suggest_extensions
+      run_command(:suggest_extensions)
+    end
+
+    def validate_options_vs_config
+      return unless @options[:parallel] && !@config_store.for_pwd.for_all_cops['UseCache']
+
+      raise OptionArgumentError, '-P/--parallel uses caching to speed up execution, so combining ' \
+                                 'with AllCops: UseCache: false is not allowed.'
+    end
+
+    def parallel_by_default!
+      # See https://github.com/rubocop/rubocop/pull/4537 for JRuby and Windows constraints.
+      return if RUBY_ENGINE != 'ruby' || RuboCop::Platform.windows?
+
+      if (@options.keys - DEFAULT_PARALLEL_OPTIONS).empty? &&
+         @config_store.for_pwd.for_all_cops['UseCache'] != false
+        puts 'Use parallel by default.' if @options[:debug]
+
+        @options[:parallel] = true
+      end
+    end
+
+    def act_on_options
+      set_options_to_config_loader
+      set_options_to_pending_cops_reporter
+      handle_editor_mode
+
+      @config_store.apply_options!(@options)
+      # Set cache root after apply_options! to ensure force_default_config is applied first.
+      early_cache_root = ConfigLoader.cache_root(@options[:cache_root])
+      ConfigLoader.cache_root = ResultCache.cache_root(@config_store, @options[:cache_root])
+      warn_if_cache_root_changed(early_cache_root, ConfigLoader.cache_root)
+
+      handle_exiting_options
+
+      if @options[:color]
+        # color output explicitly forced on
+        Rainbow.enabled = true
+      elsif @options[:color] == false
+        # color output explicitly forced off
+        Rainbow.enabled = false
+      end
+    end
+
+    def set_options_to_config_loader
+      ConfigLoader.debug = @options[:debug]
+      ConfigLoader.disable_pending_cops = @options[:disable_pending_cops]
+      ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
+      ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
+      ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
+      ConfigLoader.enabled_by_default = @options[:enable_all_cops]
+      ConfigLoader.disabled_by_default = @options[:disable_all_cops]
+    end
+
+    def set_options_to_pending_cops_reporter
+      PendingCopsReporter.disable_pending_cops = @options[:disable_pending_cops]
+      PendingCopsReporter.enable_pending_cops = @options[:enable_pending_cops]
+    end
+
+    def handle_editor_mode
+      RuboCop::LSP.enable if @options[:editor_mode]
+    end
+
+    def handle_exiting_options
+      return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
+
+      run_command(:version) if @options[:version] || @options[:verbose_version]
+      %i[show_cops list_enabled_cops_for show_docs_url lsp mcp].each do |name|
+        run_command(name) if @options[name]
+      end
+      raise Finished
+    end
+
+    def apply_default_formatter
+      # This must be done after the options have already been processed,
+      # because they can affect how ConfigStore behaves
+      @options[:formatters] ||= begin
+        if @options[:auto_gen_config]
+          formatter = 'autogenconf'
+        else
+          cfg = @config_store.for_pwd.for_all_cops
+          formatter = cfg['DefaultFormatter'] || 'progress'
+        end
+        [[formatter, @options[:output_path]]]
+      end
+    end
+
+    def report_pending_cops
+      PendingCopsReporter.warn_if_needed(@config_store.for_pwd)
+    end
+
+    def warn_if_cache_root_changed(early, desired)
+      return if early == desired
+      # Normalize paths to avoid false positives from symlink resolution differences
+      if File.exist?(early) && File.exist?(desired) &&
+         File.realpath(early) == File.realpath(desired)
+        return
+      end
+
+      warn Rainbow(
+        "Warning: Remote configuration cache files were stored in `#{early}` " \
+        "because a desired cache root (`#{desired}`) was not set at the top level. " \
+        'Consider setting `AllCops: CacheRootDirectory` in your toplevel configuration file, ' \
+        'using the `RUBOCOP_CACHE_ROOT` environment variable, or using CLI options.'
+      ).yellow
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/comment_config.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class parses the special `rubocop:disable` comments in a source
+  # and provides a way to check if each cop is enabled at arbitrary line.
+  class CommentConfig
+    extend SimpleForwardable
+
+    CONFIG_DISABLED_LINE_RANGE_MIN = -Float::INFINITY
+
+    # This class provides an API compatible with RuboCop::DirectiveComment
+    # to be used for cops that are disabled in the config file
+    class ConfigDisabledCopDirectiveComment
+      include RuboCop::Ext::Comment
+
+      attr_reader :text, :loc, :line_number
+
+      Loc = Struct.new(:expression)
+      Expression = Struct.new(:line)
+
+      def initialize(cop_name)
+        @text = "# rubocop:disable #{cop_name}"
+        @line_number = CONFIG_DISABLED_LINE_RANGE_MIN
+        @loc = Loc.new(Expression.new(CONFIG_DISABLED_LINE_RANGE_MIN))
+      end
+    end
+
+    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
+
+    attr_reader :processed_source
+
+    def_delegators :@processed_source, :config, :registry
+
+    def initialize(processed_source)
+      @processed_source = processed_source
+      @no_directives = !processed_source.raw_source.include?('rubocop')
+      @stack = []
+    end
+
+    def cop_enabled_at_line?(cop, line_number)
+      cop = cop.cop_name if cop.respond_to?(:cop_name)
+      disabled_line_ranges = cop_disabled_line_ranges[cop]
+      return true unless disabled_line_ranges
+
+      disabled_line_ranges.none? { |range| range.include?(line_number) }
+    end
+
+    def cop_opted_in?(cop)
+      opt_in_cops.include?(cop.cop_name)
+    end
+
+    def cop_disabled_line_ranges
+      @cop_disabled_line_ranges ||= analyze
+    end
+
+    def extra_enabled_comments
+      disable_count = Hash.new(0)
+      registry.disabled(config).each do |cop|
+        disable_count[cop.cop_name] += 1
+      end
+      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: disable_count)
+    end
+
+    def comment_only_line?(line_number)
+      non_comment_token_line_numbers.none?(line_number)
+    end
+
+    private
+
+    def extra_enabled_comments_with_names(extras:, names:)
+      each_directive do |directive|
+        next unless comment_only_line?(directive.line_number)
+        next if directive.push? || directive.pop?
+
+        if directive.enabled_all?
+          handle_enable_all(directive, names, extras)
+        else
+          handle_switch(directive, names, extras)
+        end
+      end
+
+      extras
+    end
+
+    def opt_in_cops
+      @opt_in_cops ||= begin
+        cops = Set.new
+        each_directive do |directive|
+          next unless directive.enabled?
+          next if directive.all_cops?
+
+          cops.merge(directive.raw_cop_names)
+        end
+        cops
+      end
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def analyze
+      return {} if @no_directives
+
+      analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
+      inject_disabled_cops_directives(analyses)
+
+      each_directive do |directive|
+        if directive.push?
+          restore_point = analyses.transform_values(&:dup)
+          @stack.push(restore_point)
+          apply_push(analyses, resolve_push_cops(directive), directive.line_number)
+        elsif directive.pop?
+          pop_state(analyses, directive.line_number) if @stack.any?
+        else
+          directive.cop_names.each do |cop_name|
+            cop_name = qualified_cop_name(cop_name)
+            analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+          end
+        end
+      end
+
+      analyses.each_with_object({}) do |element, hash|
+        cop_name, analysis = *element
+        hash[cop_name] = cop_line_ranges(analysis)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    def resolve_push_cops(directive)
+      directive.push_args.transform_values do |names|
+        names.flat_map { |name| expand_cop_name(name) }
+      end
+    end
+
+    def expand_cop_name(name)
+      registry = Cop::Registry.global
+      cops = registry.department?(name) ? registry.names_for_department(name) : [name]
+      cops.map { |c| qualified_cop_name(c) }
+    end
+
+    def apply_push(analyses, resolved_cops, line)
+      resolved_cops.each do |op, cops|
+        cops.each { |cop| apply_cop_op(analyses, op, cop, line) }
+      end
+    end
+
+    def apply_cop_op(analyses, operation, cop, line)
+      analysis = analyses[cop]
+      if operation == '-' && !analysis.start_line_number
+        analyses[cop] = CopAnalysis.new(analysis.line_ranges, line)
+      elsif operation == '+' && analysis.start_line_number
+        analyses[cop] =
+          CopAnalysis.new(analysis.line_ranges + [analysis.start_line_number..line], nil)
+      end
+    end
+
+    def pop_state(analyses, line)
+      restore_point = @stack.pop
+      (restore_point.keys | analyses.keys).each do |cop|
+        current = analyses[cop]
+        new_range = current.start_line_number ? [current.start_line_number..(line - 1)] : []
+        new_start = restore_point[cop]&.start_line_number ? line : nil
+        analyses[cop] = CopAnalysis.new(current.line_ranges + new_range, new_start)
+      end
+    end
+
+    def inject_disabled_cops_directives(analyses)
+      registry.disabled(config).each do |cop|
+        analyses[cop.cop_name] = analyze_cop(
+          analyses[cop.cop_name],
+          DirectiveComment.new(ConfigDisabledCopDirectiveComment.new(cop.cop_name))
+        )
+      end
+    end
+
+    def analyze_cop(analysis, directive)
+      # Disabling cops after comments like `#=SomeDslDirective` does not related to single line
+      if !comment_only_line?(directive.line_number) || directive.single_line?
+        analyze_single_line(analysis, directive)
+      elsif directive.disabled?
+        analyze_disabled(analysis, directive)
+      else
+        analyze_rest(analysis, directive)
+      end
+    end
+
+    def analyze_single_line(analysis, directive)
+      return analysis unless directive.disabled?
+
+      line = directive.line_number
+      CopAnalysis.new(analysis.line_ranges + [(line..line)], analysis.start_line_number)
+    end
+
+    def analyze_disabled(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
+      CopAnalysis.new(new_ranges, line)
+    end
+
+    def analyze_rest(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
+      CopAnalysis.new(new_ranges, nil)
+    end
+
+    def cop_line_ranges(analysis)
+      return analysis.line_ranges unless analysis.start_line_number
+
+      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
+    end
+
+    def each_directive
+      return if @no_directives
+
+      processed_source.comments.each do |comment|
+        directive = DirectiveComment.new(comment)
+        yield directive if directive.cop_names
+      end
+    end
+
+    def qualified_cop_name(cop_name)
+      Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
+    end
+
+    def non_comment_token_line_numbers
+      @non_comment_token_line_numbers ||= begin
+        non_comment_tokens = processed_source.tokens.reject(&:comment?)
+        non_comment_tokens.map(&:line).uniq
+      end
+    end
+
+    def handle_enable_all(directive, names, extras)
+      enabled_cops = 0
+      names.each do |name, counter|
+        next unless counter.positive?
+
+        names[name] -= 1
+        enabled_cops += 1
+      end
+
+      extras[directive.comment] << 'all' if enabled_cops.zero?
+    end
+
+    # Collect cops that have been disabled or enabled by name in a directive comment
+    # so that `Lint/RedundantCopEnableDirective` can register offenses correctly.
+    def handle_switch(directive, names, extras)
+      directive.cop_names.each do |name|
+        if directive.disabled?
+          names[name] += 1
+        elsif names[name].positive?
+          names[name] -= 1
+        else
+          extras[directive.comment] << name
+        end
+      end
+    end
+  end
+end