super-pro-sys 0.0.1

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

@@ -0,0 +1,328 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Parse different formats of magic comments.
+  #
+  # @abstract parent of three different magic comment handlers
+  class MagicComment
+    # IRB's pattern for matching magic comment tokens.
+    # @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5
+    TOKEN = '(?<token>[[:alnum:]\-_]+)'
+    KEYWORDS = {
+      encoding: '(?:en)?coding',
+      frozen_string_literal: 'frozen[_-]string[_-]literal',
+      rbs_inline: 'rbs_inline',
+      shareable_constant_value: 'shareable[_-]constant[_-]value',
+      typed: 'typed'
+    }.freeze
+
+    # Detect magic comment format and pass it to the appropriate wrapper.
+    #
+    # @param comment [String]
+    #
+    # @return [RuboCop::MagicComment]
+    def self.parse(comment)
+      case comment
+      when EmacsComment::REGEXP then EmacsComment.new(comment)
+      when VimComment::REGEXP   then VimComment.new(comment)
+      else
+        SimpleComment.new(comment)
+      end
+    end
+
+    def initialize(comment)
+      @comment = comment
+    end
+
+    def any?
+      frozen_string_literal_specified? ||
+        encoding_specified? ||
+        rbs_inline_specified? ||
+        shareable_constant_value_specified? ||
+        typed_specified?
+    end
+
+    def valid?
+      @comment.start_with?('#') && any?
+    end
+
+    # Does the magic comment enable the frozen string literal feature.
+    #
+    # Test whether the frozen string literal value is `true`. Cannot
+    # just return `frozen_string_literal` since an invalid magic comment
+    # like `# frozen_string_literal: yes` is possible and the truthy value
+    # `'yes'` does not actually enable the feature
+    #
+    # @return [Boolean]
+    def frozen_string_literal?
+      frozen_string_literal == true
+    end
+
+    def valid_literal_value?
+      [true, false].include?(frozen_string_literal)
+    end
+
+    def valid_rbs_inline_value?
+      %w[enabled disabled].include?(extract_rbs_inline_value)
+    end
+
+    def valid_shareable_constant_value?
+      %w[none literal experimental_everything experimental_copy].include?(shareable_constant_value)
+    end
+
+    # Was a magic comment for the frozen string literal found?
+    #
+    # @return [Boolean]
+    def frozen_string_literal_specified?
+      specified?(frozen_string_literal)
+    end
+
+    # Was a shareable_constant_value specified?
+    #
+    # @return [Boolean]
+    def shareable_constant_value_specified?
+      specified?(shareable_constant_value)
+    end
+
+    # Expose the `frozen_string_literal` value coerced to a boolean if possible.
+    #
+    # @return [Boolean] if value is `true` or `false` in any case
+    # @return [nil] if frozen_string_literal comment isn't found
+    # @return [String] if comment is found but isn't true or false
+    def frozen_string_literal
+      return unless (setting = extract_frozen_string_literal)
+
+      case setting.downcase
+      when 'true'  then true
+      when 'false' then false
+      else
+        setting
+      end
+    end
+
+    # Expose the `shareable_constant_value` value coerced to a boolean if possible.
+    #
+    # @return [String] for shareable_constant_value config
+    def shareable_constant_value
+      extract_shareable_constant_value
+    end
+
+    def encoding_specified?
+      specified?(encoding)
+    end
+
+    def rbs_inline_specified?
+      valid_rbs_inline_value?
+    end
+
+    # Was the Sorbet `typed` sigil specified?
+    #
+    # @return [Boolean]
+    def typed_specified?
+      specified?(extract_typed)
+    end
+
+    def typed
+      extract_typed
+    end
+
+    private
+
+    def specified?(value)
+      !value.nil?
+    end
+
+    # Match the entire comment string with a pattern and take the first capture.
+    #
+    # @param pattern [Regexp]
+    #
+    # @return [String] if pattern matched
+    # @return [nil] otherwise
+    def extract(pattern)
+      @comment[pattern, :token]
+    end
+
+    # Parent to Vim and Emacs magic comment handling.
+    #
+    # @abstract
+    class EditorComment < MagicComment
+      def encoding
+        match(self.class::KEYWORDS[:encoding])
+      end
+
+      # Rewrite the comment without a given token type
+      def without(type)
+        remaining = tokens.grep_v(/\A#{self.class::KEYWORDS[type.to_sym]}/)
+        return '' if remaining.empty?
+
+        self.class::FORMAT % remaining.join(self.class::SEPARATOR)
+      end
+
+      private
+
+      # Find a token starting with the provided keyword and extract its value.
+      #
+      # @param keyword [String]
+      #
+      # @return [String] extracted value if it is found
+      # @return [nil] otherwise
+      def match(keyword)
+        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*#{TOKEN}\z/
+
+        tokens.each do |token|
+          next unless (value = token[pattern, :token])
+
+          return value.downcase
+        end
+
+        nil
+      end
+
+      # Individual tokens composing an editor specific comment string.
+      #
+      # @return [Array<String>]
+      def tokens
+        extract(self.class::REGEXP).split(self.class::SEPARATOR).map(&:strip)
+      end
+    end
+
+    # Wrapper for Emacs style magic comments.
+    #
+    # @example Emacs style comment
+    #   comment = RuboCop::MagicComment.parse(
+    #     '# -*- encoding: ASCII-8BIT -*-'
+    #   )
+    #
+    #   comment.encoding # => 'ascii-8bit'
+    #
+    # @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
+    # @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y
+    class EmacsComment < EditorComment
+      REGEXP    = /-\*-(?<token>.+)-\*-/.freeze
+      FORMAT    = '# -*- %s -*-'
+      SEPARATOR = ';'
+      OPERATOR  = ':'
+
+      def new_frozen_string_literal(value)
+        "# -*- frozen_string_literal: #{value} -*-"
+      end
+
+      private
+
+      def extract_frozen_string_literal
+        match(KEYWORDS[:frozen_string_literal])
+      end
+
+      # Emacs comments cannot specify RBS::inline behavior.
+      def extract_rbs_inline_value; end
+
+      def extract_shareable_constant_value
+        match(KEYWORDS[:shareable_constant_value])
+      end
+
+      # Emacs comments cannot specify Sorbet typechecking behavior.
+      def extract_typed; end
+    end
+
+    # Wrapper for Vim style magic comments.
+    #
+    # @example Vim style comment
+    #   comment = RuboCop::MagicComment.parse(
+    #     '# vim: filetype=ruby, fileencoding=ascii-8bit'
+    #   )
+    #
+    #   comment.encoding # => 'ascii-8bit'
+    class VimComment < EditorComment
+      REGEXP    = /#\s*vim:\s*(?<token>.+)/.freeze
+      FORMAT    = '# vim: %s'
+      SEPARATOR = ', '
+      OPERATOR  = '='
+      KEYWORDS = MagicComment::KEYWORDS.merge(encoding: 'fileencoding').freeze
+
+      # For some reason the fileencoding keyword only works if there
+      # is at least one other token included in the string. For example
+      #
+      #    # works
+      #      # vim: foo=bar, fileencoding=ascii-8bit
+      #
+      #    # does nothing
+      #      # vim: foo=bar, fileencoding=ascii-8bit
+      #
+      def encoding
+        super if tokens.size > 1
+      end
+
+      # Vim comments cannot specify frozen string literal behavior.
+      def frozen_string_literal; end
+
+      # Vim comments cannot specify RBS::inline behavior.
+      def extract_rbs_inline_value; end
+
+      # Vim comments cannot specify shareable constant values behavior.
+      def shareable_constant_value; end
+
+      # Vim comments cannot specify Sorbet typechecking behavior.
+      def extract_typed; end
+    end
+
+    # Wrapper for regular magic comments not bound to an editor.
+    #
+    # Simple comments can only specify one setting per comment.
+    #
+    # @example frozen string literal comments
+    #   comment1 = RuboCop::MagicComment.parse('# frozen_string_literal: true')
+    #   comment1.frozen_string_literal # => true
+    #   comment1.encoding              # => nil
+    #
+    # @example encoding comments
+    #   comment2 = RuboCop::MagicComment.parse('# encoding: utf-8')
+    #   comment2.frozen_string_literal # => nil
+    #   comment2.encoding              # => 'utf-8'
+    class SimpleComment < MagicComment
+      FSTRING_LITERAL_COMMENT = 'frozen_string_literal:\s*(true|false)'
+
+      # Match `encoding` or `coding`
+      def encoding
+        extract(/\A\s*\#\s*(#{FSTRING_LITERAL_COMMENT})?\s*#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
+      end
+
+      # Rewrite the comment without a given token type
+      def without(type)
+        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/io)
+          ''
+        else
+          @comment
+        end
+      end
+
+      def new_frozen_string_literal(value)
+        "# frozen_string_literal: #{value}"
+      end
+
+      private
+
+      # Extract `frozen_string_literal`.
+      #
+      # The `frozen_string_literal` magic comment only works if it
+      # is the only text in the comment.
+      #
+      # Case-insensitive and dashes/underscores are acceptable.
+      # @see https://github.com/ruby/ruby/blob/78b95b49f8/parse.y#L7134-L7138
+      def extract_frozen_string_literal
+        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
+      end
+
+      def extract_rbs_inline_value
+        extract(/\A\s*#\s*#{KEYWORDS[:rbs_inline]}:\s*#{TOKEN}\s*\z/io)
+      end
+
+      def extract_shareable_constant_value
+        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*#{TOKEN}\s*\z/io)
+      end
+
+      def extract_typed
+        extract(/\A\s*#\s*#{KEYWORDS[:typed]}:\s*#{TOKEN}\s*\z/io)
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/mcp/server.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+begin
+  require 'mcp'
+
+  required_mcp_version = '0.6.0'
+
+  if Gem::Version.new(required_mcp_version) > Gem::Version.new(MCP::VERSION)
+    # While `mcp` is not a runtime dependency, users may have an outdated version installed.
+    warn <<~MESSAGE
+      Error: `mcp` gem version #{MCP::VERSION} was loaded, but `rubocop --mcp` requires #{required_mcp_version}.
+      - If you're using Bundler and don't yet have `gem 'mcp'` as a dependency, add it now.
+      - If you're using Bundler and already have `gem 'mcp'` as a dependency, update it to the most recent version.
+      - If you don't use Bundler, run `gem update mcp`.
+    MESSAGE
+    exit!
+  end
+rescue LoadError => e
+  raise unless e.path == 'mcp'
+
+  warn <<~MESSAGE
+    Error: Unable to load `mcp` gem. Add `gem 'mcp', '~> 0.6'` to your Gemfile, or run `gem install mcp`.
+  MESSAGE
+
+  exit!
+end
+
+require_relative '../lsp'
+require_relative '../lsp/runtime'
+
+module RuboCop
+  module MCP
+    # RuboCop MCP Server.
+    # @api private
+    class Server
+      def initialize(config_store)
+        @config_store = config_store
+        @runtime = RuboCop::LSP::Runtime.new(@config_store)
+        @options = {}
+      end
+
+      def start
+        # No `protocol_version` is specified because draft feature by default can be used.
+        server = ::MCP::Server.new(
+          name: 'rubocop_mcp_server',
+          version: RuboCop::Version::STRING,
+          tools: [inspection_tool, autocorrection_tool]
+        )
+
+        ::MCP::Server::Transports::StdioTransport.new(server).open
+      end
+
+      private
+
+      def inspection_tool
+        build_tool(
+          name: 'rubocop_inspection',
+          description: 'Inspect Ruby code for offenses. ' \
+                       'Provide `source_code` to check inline code or `path` to check files.',
+          title: "RuboCop's inspection",
+          destructive_hint: false,
+          idempotent_hint: true,
+          read_only_hint: true,
+          safety_required: false
+        ) do |path, source_code|
+          run_inspection(path, source_code)
+        end
+      end
+
+      def autocorrection_tool
+        build_tool(
+          name: 'rubocop_autocorrection',
+          description: 'Autocorrect RuboCop offenses in Ruby code. ' \
+                       'Provide `source_code` to correct inline code or `path` to correct files. ' \
+                       'Set `safety` to false to include unsafe corrections.',
+          title: "RuboCop's autocorrection",
+          destructive_hint: true,
+          idempotent_hint: false,
+          read_only_hint: false,
+          safety_required: true
+        ) do |path, source_code, safety|
+          run_autocorrection(path, source_code, safety)
+        end
+      end
+
+      def run_inspection(path, source_code)
+        if source_code
+          offenses = @runtime.offenses(path || 'example.rb', source_code, source_code.encoding)
+          offenses.to_json
+        else
+          process_files(path, filter_empty: true) do |file, source|
+            offenses = @runtime.offenses(file, source, source.encoding)
+
+            { path: PathUtil.relative_path(file), offenses: offenses }
+          end
+        end
+      end
+
+      def run_autocorrection(path, source_code, safety)
+        command = safety ? 'rubocop.formatAutocorrects' : 'rubocop.formatAutocorrectsAll'
+
+        if source_code
+          @runtime.format(path || 'example.rb', source_code, command: command).tap do |corrected|
+            write_file(path, corrected) if path
+          end
+        else
+          process_files(path) do |file, source|
+            @runtime.format(file, source, command: command).then do |corrected|
+              write_file(file, corrected)
+
+              { path: PathUtil.relative_path(file), corrected: source != corrected }
+            end
+          end
+        end
+      end
+
+      def process_files(path, filter_empty: false)
+        target_finder = RuboCop::TargetFinder.new(@config_store, @options)
+        target_files = target_finder.find(path ? [path] : [], :only_recognized_file_types)
+        all_files = target_files.map { |file| yield(file, read_file(file)) }
+        files = filter_empty ? all_files.reject { |f| f[:offenses]&.empty? } : all_files
+
+        { files: files, summary: build_summary(target_files, all_files) }.to_json
+      end
+
+      def read_file(file)
+        config = @config_store.for_file(file)
+        RuboCop::ProcessedSource.from_file(
+          file, config.target_ruby_version, parser_engine: config.parser_engine
+        ).raw_source
+      rescue Errno::ENOENT
+        raise RuboCop::Error, "No such file or directory: #{file}"
+      end
+
+      def write_file(file, content)
+        File.write(file, content)
+      rescue Errno::EACCES
+        raise RuboCop::Error, "Permission denied: #{file}"
+      rescue Errno::ENOSPC
+        raise RuboCop::Error, "No space left on device: #{file}"
+      rescue Errno::EROFS
+        raise RuboCop::Error, "Read-only file system: #{file}"
+      end
+
+      # NOTE: It is useful for RuboCop's result summary to be shown in the LLM's responses
+      # during interactions, so the summary is returned in a form that is easy for the LLM
+      # to reason about. Since LLM execution is non-deterministic, it is also sensible to
+      # compute the summary deterministically at this stage.
+      def build_summary(target_files, files)
+        summary = { target_file_count: target_files.count }
+        if files.first&.key?(:offenses)
+          summary[:offense_count] = files.sum { |f| f[:offenses].size }
+        else
+          summary[:corrected_file_count] = files.count { |f| f[:corrected] }
+        end
+        summary
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def build_tool(
+        name:, description:,
+        title:, destructive_hint:, idempotent_hint:, read_only_hint:, safety_required:
+      )
+        if safety_required
+          safety_property = { safety: { type: 'boolean' } }
+          required = ['safety']
+        else
+          safety_property = {}
+          required = nil
+        end
+
+        ::MCP::Tool.define(
+          name: name,
+          description: description,
+          input_schema: {
+            properties: {
+              path: { type: 'string' },
+              source_code: { type: 'string' }
+            }.merge(safety_property),
+            required: required
+          }.compact,
+          annotations: {
+            title: title,
+            destructive_hint: destructive_hint,
+            idempotent_hint: idempotent_hint,
+            open_world_hint: false,
+            read_only_hint: read_only_hint
+          }
+        ) do |path: nil, source_code: nil, safety: true|
+          result = yield(path, source_code, safety)
+
+          ::MCP::Tool::Response.new([{ type: 'text', text: result }])
+        rescue RuboCop::Error => e
+          ::MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Common functionality for finding names that are similar to a given name.
+  # @api private
+  module NameSimilarity
+    module_function
+
+    def find_similar_name(target_name, names)
+      similar_names = find_similar_names(target_name, names)
+
+      similar_names.first
+    end
+
+    def find_similar_names(target_name, names)
+      # DidYouMean::SpellChecker is not available in all versions of Ruby, and
+      # even on versions where it *is* available (>= 2.3), it is not always
+      # required correctly. So we do a feature check first.
+      # See: https://github.com/rubocop/rubocop/issues/7979
+      return [] unless defined?(DidYouMean::SpellChecker)
+
+      names = names.dup
+      names.delete(target_name)
+
+      spell_checker = DidYouMean::SpellChecker.new(dictionary: names)
+      spell_checker.correct(target_name)
+    end
+  end
+end