standard 0.1.0 → 1.51.1

data/lib/standard/lsp/routes.rb

@@ -0,0 +1,175 @@
+require_relative "kills_server"
+
+module Standard
+  module Lsp
+    class Routes
+      def initialize(writer, logger, standardizer)
+        @writer = writer
+        @logger = logger
+        @standardizer = standardizer
+
+        @text_cache = {}
+        @kills_server = KillsServer.new
+      end
+
+      def self.handle(name, &block)
+        define_method(:"handle_#{name}", &block)
+      end
+
+      def for(name)
+        name = "handle_#{name}"
+        if respond_to?(name)
+          method(name)
+        end
+      end
+
+      handle "initialize" do |request|
+        @writer.write(id: request[:id], result: Proto::Interface::InitializeResult.new(
+          capabilities: Proto::Interface::ServerCapabilities.new(
+            document_formatting_provider: true,
+            text_document_sync: Proto::Interface::TextDocumentSyncOptions.new(
+              change: Proto::Constant::TextDocumentSyncKind::FULL,
+              open_close: true
+            )
+          )
+        ))
+      end
+
+      handle "initialized" do |request|
+        @logger.puts "Standard Ruby v#{Standard::VERSION} LSP server initialized, pid #{Process.pid}"
+      end
+
+      handle "shutdown" do |request|
+        @logger.puts "Client asked to shutdown Standard LSP server."
+        @kills_server.call do
+          @writer.write(id: request[:id], result: nil)
+          @logger.puts "Exiting..."
+        end
+      end
+
+      handle "textDocument/didChange" do |request|
+        params = request[:params]
+        result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
+        @writer.write(result)
+      end
+
+      handle "textDocument/didOpen" do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @writer.write(result)
+      end
+
+      handle "textDocument/didClose" do |request|
+        @text_cache.delete(request.dig(:params, :textDocument, :uri))
+      end
+
+      handle "textDocument/formatting" do |request|
+        uri = request[:params][:textDocument][:uri]
+        @writer.write({id: request[:id], result: format_file(uri)})
+      end
+
+      handle "workspace/didChangeConfiguration" do |_request|
+        @logger.puts "Ignoring workspace/didChangeConfiguration"
+      end
+
+      CONFIGURATION_FILE_PATTERNS = [
+        ".standard.yml",
+        ".standard_todo.yml"
+      ].freeze
+
+      handle "workspace/didChangeWatchedFiles" do |request|
+        if request[:params][:changes].any? { |change|
+          CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
+        }
+          @logger.puts "Configuration file changed; restart required"
+          @kills_server.call
+        end
+      end
+
+      handle "workspace/executeCommand" do |request|
+        if request[:params][:command] == "standardRuby.formatAutoFixes"
+          uri = request[:params][:arguments][0][:uri]
+          @writer.write({
+            id: request[:id],
+            method: "workspace/applyEdit",
+            params: {
+              label: "Format with Standard Ruby auto-fixes",
+              edit: {
+                changes: {
+                  uri => format_file(uri)
+                }
+              }
+            }
+          })
+        else
+          handle_unsupported_method(request, request[:params][:command])
+        end
+      end
+
+      handle "textDocument/didSave" do |_request|
+        # Nothing to do
+      end
+
+      handle "$/cancelRequest" do |_request|
+        # Can't cancel anything because single-threaded
+      end
+
+      handle "$/setTrace" do |_request|
+        # No-op, we log everything
+      end
+
+      def handle_unsupported_method(request, method = request[:method])
+        @writer.write({id: request[:id], error: Proto::Interface::ResponseError.new(
+          code: Proto::Constant::ErrorCodes::METHOD_NOT_FOUND,
+          message: "Unsupported Method: #{method}"
+        )})
+        @logger.puts "Unsupported Method: #{method}"
+      end
+
+      def handle_method_missing(request)
+        if request.key?(:id)
+          @writer.write({id: request[:id], result: nil})
+        end
+      end
+
+      private
+
+      def uri_to_path(uri)
+        uri.sub(%r{^file://}, "")
+      end
+
+      def format_file(file_uri)
+        text = @text_cache[file_uri]
+        if text.nil?
+          @logger.puts "Format request arrived before text synchonized; skipping: `#{file_uri}'"
+          []
+        else
+          new_text = @standardizer.format(uri_to_path(file_uri), text)
+          if new_text == text
+            []
+          else
+            [{
+              newText: new_text,
+              range: {
+                start: {line: 0, character: 0},
+                end: {line: text.count("\n") + 1, character: 0}
+              }
+            }]
+          end
+        end
+      end
+
+      def diagnostic(file_uri, text)
+        @text_cache[file_uri] = text
+
+        {
+          method: "textDocument/publishDiagnostics",
+          params: {
+            uri: file_uri,
+            diagnostics: @standardizer.offenses(uri_to_path(file_uri), text)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/standard/lsp/server.rb

@@ -0,0 +1,37 @@
+require "language_server-protocol"
+require_relative "standardizer"
+require_relative "routes"
+require_relative "logger"
+
+module Standard
+  module Lsp
+    Proto = LanguageServer::Protocol
+    SEV = Proto::Constant::DiagnosticSeverity
+
+    class Server
+      def initialize(config)
+        @writer = Proto::Transport::Io::Writer.new($stdout)
+        @reader = Proto::Transport::Io::Reader.new($stdin)
+        @logger = Logger.new
+        @standardizer = Standard::Lsp::Standardizer.new(config)
+        @routes = Routes.new(@writer, @logger, @standardizer)
+      end
+
+      def start
+        RuboCop::LSP.enable
+        @reader.read do |request|
+          if !request.key?(:method)
+            @routes.handle_method_missing(request)
+          elsif (route = @routes.for(request[:method]))
+            route.call(request)
+          else
+            @routes.handle_unsupported_method(request)
+          end
+        rescue => e
+          @logger.puts "Error #{e.class} #{e.message[0..100]}"
+          @logger.puts e.backtrace.inspect
+        end
+      end
+    end
+  end
+end

data/lib/standard/lsp/standardizer.rb

@@ -0,0 +1,34 @@
+require_relative "stdin_rubocop_runner"
+require_relative "diagnostic"
+
+module Standard
+  module Lsp
+    class Standardizer
+      def initialize(config)
+        @diagnostic_runner = ::Standard::Lsp::StdinRubocopRunner.new(config)
+        @format_runner = ::Standard::Lsp::StdinRubocopRunner.new(config.dup.tap { |c|
+          c.rubocop_options[:autocorrect] = true
+        })
+        @cop_registry = RuboCop::Cop::Registry.global.to_h
+      end
+
+      def format(path, text)
+        @format_runner.run(path, text)
+        @format_runner.formatted_source
+      end
+
+      def offenses(path, text, document_encoding = nil)
+        @diagnostic_runner.run(path, text)
+
+        @diagnostic_runner.offenses.map do |offense|
+          Diagnostic.new(
+            document_encoding,
+            offense,
+            path,
+            @cop_registry[offense.cop_name]&.first
+          ).to_lsp_diagnostic(@diagnostic_runner.config_for_working_directory)
+        end
+      end
+    end
+  end
+end

data/lib/standard/lsp/stdin_rubocop_runner.rb

@@ -0,0 +1,71 @@
+module Standard
+  module Lsp
+    # Originally lifted from:
+    # https://github.com/Shopify/ruby-lsp/blob/8d4c17efce4e8ecc8e7c557ab2981db6b22c0b6d/lib/ruby_lsp/requests/support/rubocop_runner.rb#L20
+    class StdinRubocopRunner < ::RuboCop::Runner
+      class ConfigurationError < StandardError; end
+
+      attr_reader :offenses
+
+      attr_reader :config_for_working_directory
+
+      DEFAULT_RUBOCOP_OPTIONS = {
+        stderr: true,
+        force_exclusion: true,
+        formatters: ["RuboCop::Formatter::BaseFormatter"],
+        raise_cop_error: true,
+        todo_file: nil,
+        todo_ignore_files: []
+      }.freeze
+
+      def initialize(config)
+        @options = {}
+        @offenses = []
+        @errors = []
+        @warnings = []
+
+        @config_for_working_directory = config.rubocop_config_store.for_pwd
+
+        super(
+          config.rubocop_options.merge(DEFAULT_RUBOCOP_OPTIONS),
+          config.rubocop_config_store
+        )
+      end
+
+      def run(path, contents)
+        @errors = []
+        @warnings = []
+        @offenses = []
+        @options[:stdin] = contents
+
+        super([path])
+
+        raise Interrupt if aborting?
+      rescue ::RuboCop::Runner::InfiniteCorrectionLoop => error
+        if defined?(::RubyLsp::Requests::Formatting::Error)
+          raise ::RubyLsp::Requests::Formatting::Error, error.message
+        else
+          raise error
+        end
+      rescue ::RuboCop::ValidationError => error
+        raise ConfigurationError, error.message
+      rescue => error
+        if defined?(::RubyLsp::Requests::Formatting::Error)
+          raise ::RubyLsp::Requests::Support::InternalRuboCopError, error
+        else
+          raise error
+        end
+      end
+
+      def formatted_source
+        @options[:stdin]
+      end
+
+      private
+
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+    end
+  end
+end

data/lib/standard/merges_settings.rb

@@ -19,21 +19,24 @@ module Standard
     private
 
     def separate_argv(argv)
-      argv.partition { |flag|
-        ["--fix", "--no-fix", "--version", "-v", "--help", "-h"].include?(flag)
-      }
+      argv.partition do |flag|
+        ["--generate-todo", "--fix", "--fix-unsafely", "--no-fix", "--version", "-v", "--verbose-version", "-V", "--help", "-h", "--lsp"].include?(flag)
+      end
     end
 
     def parse_standard_argv(argv)
-      argv.each_with_object({}) { |arg, cli_flags|
+      argv.each_with_object({}) do |arg, cli_flags|
         if arg == "--fix"
-          cli_flags[:auto_correct] = true
-          cli_flags[:safe_auto_correct] = true
+          cli_flags[:autocorrect] = true
+          cli_flags[:safe_autocorrect] = true
+        elsif arg == "--fix-unsafely"
+          cli_flags[:autocorrect] = true
+          cli_flags[:safe_autocorrect] = false
         elsif arg == "--no-fix"
-          cli_flags[:auto_correct] = false
-          cli_flags[:safe_auto_correct] = false
+          cli_flags[:autocorrect] = false
+          cli_flags[:safe_autocorrect] = false
         end
-      }
+      end
     end
 
     def determine_command(argv)
@@ -41,6 +44,12 @@ module Standard
         :help
       elsif (argv & ["--version", "-v"]).any?
         :version
+      elsif (argv & ["--verbose-version", "-V"]).any?
+        :verbose_version
+      elsif (argv & ["--generate-todo"]).any?
+        :genignore
+      elsif (argv & ["--lsp"]).any?
+        :lsp
       else
         :rubocop
       end
@@ -48,10 +57,12 @@ module Standard
 
     def merge(standard_yaml, standard_cli_flags, rubocop_cli_flags)
       {
-        auto_correct: standard_yaml[:fix],
-        safe_auto_correct: standard_yaml[:fix],
+        autocorrect: standard_yaml[:fix],
+        safe_autocorrect: true,
         formatters: [[standard_yaml[:format] || "Standard::Formatter", nil]],
         parallel: standard_yaml[:parallel],
+        todo_file: standard_yaml[:todo_file],
+        todo_ignore_files: standard_yaml[:todo_ignore_files]
       }.merge(standard_cli_flags).merge(rubocop_cli_flags)
     end
 

data/lib/standard/plugin/combines_plugin_configs.rb

@@ -0,0 +1,15 @@
+module Standard
+  module Plugin
+    class CombinesPluginConfigs
+      def initialize
+        @initializes_plugins = InitializesPlugins.new
+        @merges_plugins_into_rubocop_config = MergesPluginsIntoRubocopConfig.new
+      end
+
+      def call(options_config, standard_config)
+        plugins = @initializes_plugins.call(standard_config[:plugins])
+        @merges_plugins_into_rubocop_config.call(options_config, standard_config, plugins, permit_merging: true)
+      end
+    end
+  end
+end

data/lib/standard/plugin/creates_runner_context.rb

@@ -0,0 +1,15 @@
+module Standard
+  module Plugin
+    class CreatesRunnerContext
+      def call(standard_config)
+        LintRoller::Context.new(
+          runner: :standard,
+          runner_version: Standard::VERSION,
+          engine: :rubocop,
+          engine_version: RuboCop::Version.version,
+          target_ruby_version: standard_config[:ruby_version]
+        )
+      end
+    end
+  end
+end

data/lib/standard/plugin/determines_class_constant.rb

@@ -0,0 +1,56 @@
+module Standard
+  module Plugin
+    class DeterminesClassConstant
+      def call(plugin_name, user_config)
+        require_plugin(user_config["require_path"])
+
+        if (constant_name = user_config["plugin_class_name"])
+          begin
+            Kernel.const_get(constant_name)
+          rescue
+            raise "Failed while configuring plugin `#{plugin_name}': no constant with name `#{constant_name}' was found"
+          end
+        else
+          begin
+            Kernel.const_get(Gem.loaded_specs[plugin_name].metadata["default_lint_roller_plugin"])
+          rescue LoadError, StandardError
+            raise <<~MSG
+              Failed loading plugin `#{plugin_name}' because we couldn't determine
+              the corresponding plugin class to instantiate.
+
+              Standard plugin class names must either be:
+
+                - If the plugin is a gem, defined in the gemspec as `default_lint_roller_plugin'
+
+                  spec.metadata["default_lint_roller_plugin"] = "MyModule::Plugin"
+
+                - Set in YAML as `plugin_class_name'; example:
+
+                  plugins:
+                    - incomplete:
+                        require_path: my_module/plugin
+                        plugin_class_name: "MyModule::Plugin"
+            MSG
+          end
+
+        end
+      end
+
+      private
+
+      def require_plugin(require_path)
+        return if require_path.nil?
+
+        begin
+          require require_path
+        rescue LoadError
+          # If require_path isn't on the load_path (and it may be hard to get it
+          # on there since standardrb is a cli), let's give folks a break and
+          # also try to load it via the current working directory. This is
+          # tested in test/standardrb_test.rb #test_plugins_options
+          require Pathname.new(Dir.pwd).join(require_path)
+        end
+      end
+    end
+  end
+end

data/lib/standard/plugin/initializes_plugins.rb

@@ -0,0 +1,23 @@
+module Standard
+  module Plugin
+    class InitializesPlugins
+      def initialize
+        @standardizes_configured_plugins = StandardizesConfiguredPlugins.new
+        @determines_class_constants = DeterminesClassConstant.new
+      end
+
+      def call(plugins)
+        plugin_configs = @standardizes_configured_plugins.call(plugins)
+        plugin_configs.map { |name_or_class, user_config|
+          if user_config["enabled"]
+            if name_or_class.is_a?(String) || name_or_class.is_a?(Symbol)
+              @determines_class_constants.call(name_or_class, user_config).new(user_config)
+            else
+              name_or_class.new(user_config)
+            end
+          end
+        }
+      end
+    end
+  end
+end

data/lib/standard/plugin/merges_plugins_into_rubocop_config.rb

@@ -0,0 +1,177 @@
+module Standard
+  module Plugin
+    class MergesPluginsIntoRubocopConfig
+      # Blank configuration object to merge plugins into, with only the following spared:
+      #   - AllCops keys set to avoid warnings about unknown properties
+      #   - Lint/Syntax must be set to avoid a nil error when verifying inherited configs
+      MANDATORY_RUBOCOP_CONFIG_KEYS = ["AllCops", "Lint/Syntax"].freeze
+
+      # AllCops keys that standard does not allow to be set by plugins
+      DISALLOWED_ALLCOPS_KEYS = [
+        "Include",
+        "Exclude",
+        "StyleGuideBaseURL",
+        "StyleGuideCopsOnly",
+        "TargetRubyVersion",
+        "EnabledByDefault",
+        "DisabledByDefault",
+
+        # The AllCops[Enabled] key is an unused artifact of #merge_with_default.
+        # See: https://github.com/rubocop/rubocop/blob/master/lib/rubocop/config_loader_resolver.rb#L81-L85
+        "Enabled"
+      ].freeze
+
+      def initialize
+        @creates_runner_context = Standard::Plugin::CreatesRunnerContext.new
+      end
+
+      def call(options_config, standard_config, plugins, permit_merging:)
+        runner_context = @creates_runner_context.call(standard_config)
+        plugin_config = combine_rubocop_configs(options_config, runner_context, plugins, permit_merging: permit_merging).to_h
+        merge_config_into_all_cops!(options_config, plugin_config)
+        merge_config_into_standard!(options_config, plugin_config, permit_merging: permit_merging)
+      end
+
+      private
+
+      def combine_rubocop_configs(options_config, runner_context, plugins, permit_merging:)
+        all_cop_keys_configured_by_plugins = all_cop_keys_previously_configured_by_plugins(options_config, permit_merging: permit_merging)
+        fake_out_rubocop_default_configuration(options_config) do |fake_config|
+          plugins.reduce(fake_config) do |combined_config, plugin|
+            RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, combined_config)
+            next_config, path = config_for_plugin(plugin, runner_context)
+
+            next_config["AllCops"], all_cop_keys_configured_by_plugins = merge_all_cop_settings(
+              combined_config["AllCops"],
+              next_config["AllCops"],
+              all_cop_keys_configured_by_plugins
+            )
+            delete_already_configured_keys!(combined_config.keys, next_config, dont_delete_keys: ["AllCops"])
+
+            RuboCop::ConfigLoader.merge_with_default(next_config, path, unset_nil: false)
+          end
+        end
+      end
+
+      def config_for_plugin(plugin, runner_context)
+        rules = plugin.rules(runner_context)
+
+        if rules.type == :path
+          [RuboCop::ConfigLoader.load_file(rules.value), rules.value]
+        elsif rules.type == :object
+          path = plugin.method(:rules).source_location[0]
+          [RuboCop::Config.create(rules.value, path, check: true), path]
+        elsif rules.type == :error
+          raise "Plugin `#{plugin.about&.name || plugin.inspect}' failed to load with error: #{rules.value.respond_to?(:message) ? rules.value.message : rules.value}"
+        end
+      end
+
+      # This is how we ensure "first-in wins": plugins can override AllCops settings that are
+      # set by RuboCop's default configuration, but once a plugin sets an AllCop setting, they
+      # have exclusive first-in-wins rights to that setting.
+      #
+      # The one exception to this are array fields, because we don't want to
+      # overwrite the AllCops defaults but rather munge the arrays (`existing |
+      # new`) to allow plugins to add to the array, for example Include and
+      # Exclude paths and patterns.
+      def merge_all_cop_settings(existing_all_cops, new_all_cops, already_configured_keys)
+        return [existing_all_cops, already_configured_keys] unless new_all_cops.is_a?(Hash)
+
+        combined_all_cops = existing_all_cops.dup
+        combined_configured_keys = already_configured_keys.dup
+
+        new_all_cops.each do |key, value|
+          if combined_all_cops[key].is_a?(Array) && value.is_a?(Array)
+            combined_all_cops[key] |= value
+            combined_configured_keys |= [key]
+          elsif !combined_configured_keys.include?(key)
+            combined_all_cops[key] = value
+            combined_configured_keys << key
+          end
+        end
+
+        [combined_all_cops, combined_configured_keys]
+      end
+
+      def delete_already_configured_keys!(configured_keys, next_config, dont_delete_keys: [])
+        duplicate_keys = configured_keys & Array(next_config&.keys)
+
+        (duplicate_keys - dont_delete_keys).each do |key|
+          next_config.delete(key)
+        end
+      end
+
+      def merge_config_into_all_cops!(options_config, plugin_config)
+        options_config["AllCops"].merge!(
+          except(plugin_config["AllCops"], DISALLOWED_ALLCOPS_KEYS)
+        )
+      end
+
+      def merge_config_into_standard!(options_config, plugin_config, permit_merging:)
+        if permit_merging
+          plugin_config.each do |key, value|
+            options_config[key] = if options_config[key].is_a?(Hash)
+              merge(options_config[key], value)
+            else
+              value
+            end
+          end
+        else
+          except(plugin_config, options_config.keys).each do |key, value|
+            options_config[key] = value
+          end
+        end
+      end
+
+      def all_cop_keys_previously_configured_by_plugins(options_config, permit_merging:)
+        if permit_merging
+          []
+        else
+          Array(options_config["AllCops"]&.keys) - RuboCop::ConfigLoader.default_configuration["AllCops"].keys
+        end
+      end
+
+      def fake_out_rubocop_default_configuration(options_config)
+        og_default_config = RuboCop::ConfigLoader.default_configuration
+        set_target_rails_version_on_all_cops_because_its_technically_not_allowed!(options_config)
+        result = yield blank_rubocop_config(options_config)
+        RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, og_default_config)
+        result
+      end
+
+      # Avoid a warning that would otherwise be emitted by any plugin that set TargetRailsVersion
+      # because it's not a default AllCops key specified in RuboCop's embedded default config.
+      #
+      # See: https://github.com/rubocop/rubocop/pull/11833
+      def set_target_rails_version_on_all_cops_because_its_technically_not_allowed!(options_config)
+        return if !options_config.key?("AllCops") || options_config["AllCops"].key?("TargetRailsVersion")
+
+        options_config["AllCops"]["TargetRailsVersion"] = nil
+      end
+
+      def blank_rubocop_config(example_config)
+        RuboCop::Config.new(example_config.to_h.slice(*MANDATORY_RUBOCOP_CONFIG_KEYS), "")
+      end
+
+      def except(hash_or_config, keys)
+        hash_or_config.to_h.except(*keys).to_h
+      end
+
+      # Always deletes nil entries, always overwrites arrays
+      # This is a simplified version of rubocop's ConfigLoader#merge:
+      # https://github.com/rubocop/rubocop/blob/v1.48.1/lib/rubocop/config_loader_resolver.rb#L98
+      def merge(old_hash, new_hash)
+        result = old_hash.merge(new_hash)
+        keys_appearing_in_both = old_hash.keys & new_hash.keys
+        keys_appearing_in_both.each do |key|
+          if new_hash[key].nil?
+            result.delete(key)
+          elsif old_hash[key].is_a?(Hash) && new_hash[key].is_a?(Hash)
+            result[key] = merge(old_hash[key], new_hash[key])
+          end
+        end
+        result
+      end
+    end
+  end
+end