standard 1.21.0 → 1.24.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b81947d8fd0c0d0ac932f947406aa3ecaa893f26861d143895c4c17d5174e12
-  data.tar.gz: 451ce5e6c758f9d12539e6ae7ee877ea3597c6cb876994e192d5ccc54bc3d453
+  metadata.gz: cc7f5e2e4baad0d0471e6aba98df29bd5d8bb3db7c4a8fc3557581572a30865b
+  data.tar.gz: 76083326596e81461fc7cf9664421d4089555d9a3b1a2f8706e2884522379611
 SHA512:
-  metadata.gz: 4b25fcaa73ce0ec0ac525497f600a8d7c37c36e780c7d913d84e1837fa77d3551ed75890b069312950a81b00376725080b0272639be67ca8e1741f9f4cb9b91c
-  data.tar.gz: cca1619ce8107cb4e8d2a5156846272759643dd1031e4fe53671ec4c8f7ae7e7f31d01ec49499ef407de6a11b89236534638890cdf93454fd6cd536dc290fe66
+  metadata.gz: 47a6281011618bc51cd198c5dad586608d97c64ed05a4146d8549739332d22d70669f24fd9a59e1508c6b1ec6d631387949d589ab97241adf296fd0c2ec5ca22
+  data.tar.gz: dbca4f6a5c7e0777e93a98f3c6f0f14b4a15210cadcad1c8489f16319e636fe92ee5de19a295389fb3cdec7b73c37bd86510aa7de0b3dd8537f8033766cbd45c

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 1.24.3
+
+* _Further_ _further_ _further_ improve `--lsp` server to ignore files correctly
+
+## 1.24.2
+
+* _Further_ _further_ improve `--lsp` server to always respond to requests
+
+## 1.24.1
+
+* _Further_ improve `--lsp` server to better support commands used by VS Code
+
+## 1.24.0
+
+* Improve `--lsp` server to better support the commands used by VS Code
+
+## 1.23.0
+
+* Update rubocop from 1.42.0 to [1.44.1](https://github.com/rubocop/rubocop/releases/tag/v1.44.1)
+
+## 1.22.1
+
+* Improve the behavior of `extend_config` to more accurately reflect how Rubocop
+extensions would behave when loaded via the `rubocop` CLI (by capturing any
+mutations to RuboCop's default configuration)
+[#512](https://github.com/testdouble/standard/pull/512)
+
+## 1.22.0
+
+* Add `extend_config` option [#506](https://github.com/testdouble/standard/pull/506)
+
+## 1.21.1
+
+* Fix standard comment directives [#498](https://github.com/testdouble/standard/pull/498)
+
 ## 1.21.0
 
 * Update rubocop-performance from 1.15.1 to [1.15.2](https://github.com/rubocop/rubocop-performance/releases/tag/v1.15.2)

data/Gemfile

@@ -7,6 +7,7 @@ gem "minitest", "~> 5.0"
 gem "pry"
 gem "rake", "~> 13.0"
 gem "gimme"
+gem "m"
 
 if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.5")
   gem "simplecov"

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    standard (1.21.0)
+    standard (1.24.3)
       language_server-protocol (~> 3.17.0.2)
-      rubocop (= 1.42.0)
+      rubocop (= 1.44.1)
       rubocop-performance (= 1.15.2)
 
 GEM
@@ -14,31 +14,34 @@ GEM
     docile (1.4.0)
     gimme (0.5.0)
     json (2.6.3)
-    language_server-protocol (3.17.0.2)
+    language_server-protocol (3.17.0.3)
+    m (1.6.1)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
     method_source (1.0.0)
     minitest (5.17.0)
     parallel (1.22.1)
-    parser (3.2.0.0)
+    parser (3.2.1.0)
       ast (~> 2.4.1)
-    pry (0.14.1)
+    pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
     rainbow (3.1.1)
     rake (13.0.6)
-    regexp_parser (2.6.1)
+    regexp_parser (2.7.0)
     rexml (3.2.5)
-    rubocop (1.42.0)
+    rubocop (1.44.1)
       json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.1.2.1)
+      parser (>= 3.2.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
       rubocop-ast (>= 1.24.1, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.24.1)
-      parser (>= 3.1.1.0)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.26.0)
+      parser (>= 3.2.1.0)
     rubocop-performance (1.15.2)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
@@ -49,7 +52,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    unicode-display_width (2.4.0)
+    unicode-display_width (2.4.2)
 
 PLATFORMS
   ruby
@@ -58,6 +61,7 @@ PLATFORMS
 DEPENDENCIES
   bundler
   gimme
+  m
   minitest (~> 5.0)
   pry
   rake (~> 13.0)

data/README.md

@@ -215,12 +215,12 @@ inherit_gem:
 
 ## Who uses Ruby Standard Style?
 
-(This section will not [look very
-familiar](https://github.com/standard/standard#who-uses-javascript-standard-style)
-if you've used StandardJS.)
+Here are a few examples of Ruby Standard-compliant teams & projects:
 
 * [Test Double](https://testdouble.com/agency)
 * [Amazon Web Services](https://aws.amazon.com/)
+* [Arrows](https://arrows.to/)
+* [Avo Admin](https://avohq.io/)
 * [Babylist](https://www.babylist.com/)
 * [Brand New Box](https://brandnewbox.com)
 * [Brave Software](https://github.com/brave-intl/publishers)
@@ -244,9 +244,7 @@ if you've used StandardJS.)
 * [RubyCI](https://ruby.ci)
 * [thoughtbot](https://thoughtbot.com/)
 
-If your team starts using Standard, [send a pull
-request](https://github.com/testdouble/standard/edit/main/README.md) to let us
-know!
+Does your team use Standard? [Add your name to the list](https://github.com/testdouble/standard/edit/main/README.md)!
 
 ## Is there a readme badge?
 
@@ -401,6 +399,87 @@ configurations](https://github.com/testdouble/standard/tree/main/config) and
 consider helping out by submitting a pull request if you find a rule that won't
 work for older Rubies.
 
+## How do I use Standard with RuboCop extensions or custom rules?
+
+If you want to use Standard in conjunction with RuboCop extensions or custom
+cops, you can specify them in your own [RuboCop configuration
+YAML](https://docs.rubocop.org/rubocop/configuration.html) files and
+`.standard.yml` using the "extend_config` setting.
+
+For a simple example, you could include [rubocop-rails](https://github.com/rubocop/rubocop-rails)
+when Standard runs by first specifying a file in `.standard.yml`:
+
+```yaml
+# .standard.yml
+
+extend_config:
+  - .standard_rubocop_extensions.yml
+```
+
+And a minimal RuboCop configuration file:
+
+```yaml
+# .standard_rubocop_extensions.yml
+
+require:
+  - rubocop-rails
+```
+
+That's it! Now, in addition to all of Standard's built-in rules, `standardrb`
+and `rake standard` will also execute the default configuration of the
+`rubocop-rails` gem without needing to invoke `rubocop` separately.
+
+For a slightly more complex example, we could add the
+[https://github.com/Betterment/betterlint] gem from our friends at
+[Betterment](https://www.betterment.com), first by telling Standard where our
+configuration file is:
+
+```yml
+# .standard.yml
+
+extend_config:
+  - .betterlint.yml
+```
+
+But if we only wanted to enable a particular rule, we could configure it more
+narrowly, like this:
+
+```yml
+# .betterlint.yml
+
+require:
+  - rubocop/cop/betterment.rb
+
+AllCops:
+  DisabledByDefault: true
+
+Betterment/UnscopedFind:
+  Enabled: true
+
+  unauthenticated_models:
+    - SystemConfiguration
+```
+
+This same approach works for more than just gems! Just require a Ruby file that
+defines or loads your [custom RuboCop
+implementation](https://docs.rubocop.org/rubocop/development.html) and configure
+it using `extend_config`.
+
+When Standard encounters an `extend_config` property, it will merge your
+configuration files with Standard's base ruleset. To prevent Standard's built-in
+rules from being modified, any configuration of rules includued in the `rubocop`
+or `rubocop-performance` gems will be ignored. Most settings under `AllCops:`
+can be configured, however, unless they'd conflict with a setting used by
+Standard (like `TargetRubyVersion`) or prevent Standard's own rules from running
+(like `StyleGuideCopsOnly`). If you specify multiple YAML files under
+`extend_config`, note that their resulting RuboCop configurations will be merged
+in order (i.e.  last-in-wins).
+
+If you find that Standard's `extend_config` feature doesn't meet your needs,
+Evil Martians also maintains [a regularly updated
+guide](https://evilmartians.com/chronicles/rubocoping-with-legacy-bring-your-ruby-code-up-to-standard)
+on how to configure RuboCop to load and execute Standard's ruleset.
+
 ## How do I change the output?
 
 Standard's built-in formatter is intentionally minimal, printing only unfixed
@@ -492,13 +571,6 @@ either:
   gem to your build, which will automatically ensure that the comment is
   prepended for every applicable file in your project
 
-## How do I use Standard with RuboCop extensions?
-
-This is not officially supported by Standard. However, Evil Martians wrote up [a
-regularly updated
-guide](https://evilmartians.com/chronicles/rubocoping-with-legacy-bring-your-ruby-code-up-to-standard)
-on how to do so.
-
 ## How often is Standard updated?
 
 We aim to update Standard once a month, in the first week of the month. In between releases, we'll be considering RuboCop updates, RuboCop Performance updates, and community contributions.

data/config/base.yml

@@ -38,6 +38,9 @@ Gemspec/DependencyVersion:
 Gemspec/DeprecatedAttributeAssignment:
   Enabled: true
 
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
 Gemspec/DuplicatedAssignment:
   Enabled: true
   Include:
@@ -824,6 +827,9 @@ Lint/UselessElseWithoutRescue:
 Lint/UselessMethodDefinition:
   Enabled: false
 
+Lint/UselessRescue:
+  Enabled: true
+
 Lint/UselessRuby2Keywords:
   Enabled: true
 
@@ -1213,6 +1219,9 @@ Style/CommentAnnotation:
 Style/CommentedKeyword:
   Enabled: false
 
+Style/ComparableClamp:
+  Enabled: true
+
 Style/ConcatArrayLiterals:
   Enabled: false
 
@@ -1269,6 +1278,7 @@ Style/EmptyCaseCondition:
 
 Style/EmptyElse:
   Enabled: true
+  AllowComments: true
   EnforcedStyle: both
 
 Style/EmptyHeredoc:
@@ -1406,6 +1416,9 @@ Style/InlineComment:
 Style/InverseMethods:
   Enabled: false
 
+Style/InvertibleUnlessCondition:
+  Enabled: false
+
 Style/IpAddresses:
   Enabled: false
 

data/config/ruby-2.3.yml

@@ -2,3 +2,6 @@ inherit_from: ./ruby-2.4.yml
 
 AllCops:
   TargetRubyVersion: 2.3
+
+Style/ComparableClamp:
+  Enabled: false

data/lib/standard/creates_config_store/merges_user_config_extensions.rb

@@ -0,0 +1,67 @@
+require_relative "../file_finder"
+
+class Standard::CreatesConfigStore
+  class MergesUserConfigExtensions
+    DISALLOWED_ALLCOPS_KEYS = [
+      "Include",
+      "Exclude",
+      "StyleGuideCopsOnly",
+      "TargetRubyVersion",
+
+      # 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 call(options_config, standard_config)
+      return unless standard_config[:extend_config]&.any?
+
+      extended_config = load_and_merge_extended_rubocop_configs(options_config, standard_config).to_h
+      merge_standard_and_user_all_cops!(options_config, extended_config)
+      merge_extended_rules_into_standard!(options_config, extended_config)
+    end
+
+    private
+
+    def load_and_merge_extended_rubocop_configs(options_config, standard_config)
+      fake_out_rubocop_default_configuration(options_config) do |fake_config|
+        standard_config[:extend_config].reduce(fake_config) do |config, path|
+          RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, config)
+
+          user_rubocop_yaml_path = Standard::FileFinder.new.call(path, Dir.pwd)
+          extension = RuboCop::ConfigLoader.load_file(user_rubocop_yaml_path)
+          RuboCop::ConfigLoader.merge_with_default(extension, path)
+        end
+      end
+    end
+
+    def merge_standard_and_user_all_cops!(options_config, extended_config)
+      options_config["AllCops"].merge!(
+        except(extended_config["AllCops"], DISALLOWED_ALLCOPS_KEYS)
+      )
+    end
+
+    def merge_extended_rules_into_standard!(options_config, extended_config)
+      except(extended_config, options_config.keys).each do |key, value|
+        options_config[key] = value
+      end
+    end
+
+    def fake_out_rubocop_default_configuration(options_config)
+      og_default_config = RuboCop::ConfigLoader.instance_variable_get(:@default_configuration)
+      result = yield blank_rubocop_config(options_config)
+      RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, og_default_config)
+      result
+    end
+
+    # Blank configuration object to merge extensions into, with all known
+    # AllCops keys set to avoid warnings about unknown properties
+    def blank_rubocop_config(example_config)
+      RuboCop::Config.new(example_config.to_h.slice("AllCops"), "")
+    end
+
+    def except(hash_or_config, keys)
+      hash_or_config.to_h.reject { |key, _| keys.include?(key) }.to_h
+    end
+  end
+end

data/lib/standard/creates_config_store.rb

@@ -3,6 +3,7 @@ require "rubocop"
 require_relative "creates_config_store/assigns_rubocop_yaml"
 require_relative "creates_config_store/sets_target_ruby_version"
 require_relative "creates_config_store/configures_ignored_paths"
+require_relative "creates_config_store/merges_user_config_extensions"
 
 module Standard
   class CreatesConfigStore
@@ -10,6 +11,7 @@ module Standard
       @assigns_rubocop_yaml = AssignsRubocopYaml.new
       @sets_target_ruby_version = SetsTargetRubyVersion.new
       @configures_ignored_paths = ConfiguresIgnoredPaths.new
+      @merges_user_config_extensions = MergesUserConfigExtensions.new
     end
 
     def call(standard_config)
@@ -17,6 +19,7 @@ module Standard
         options_config = @assigns_rubocop_yaml.call(config_store, standard_config)
         @sets_target_ruby_version.call(options_config, standard_config)
         @configures_ignored_paths.call(options_config, standard_config)
+        @merges_user_config_extensions.call(options_config, standard_config)
       end
     end
   end

data/lib/standard/loads_runner.rb

@@ -1,9 +1,23 @@
+require_relative "runners/rubocop"
+require_relative "runners/version"
+require_relative "runners/verbose_version"
+require_relative "runners/lsp"
+require_relative "runners/genignore"
+require_relative "runners/help"
+
 module Standard
   class LoadsRunner
-    # Warning: clever metaprogramming. 99% of the time this is Runners::Rubocop
+    RUNNERS = {
+      rubocop: ::Standard::Runners::Rubocop,
+      version: ::Standard::Runners::Version,
+      verbose_version: ::Standard::Runners::VerboseVersion,
+      lsp: ::Standard::Runners::Lsp,
+      genignore: ::Standard::Runners::Genignore,
+      help: ::Standard::Runners::Help
+    }.freeze
+
     def call(command)
-      require_relative "runners/#{command}"
-      ::Standard::Runners.const_get(command.to_s.capitalize).new
+      RUNNERS[command].new
     end
   end
 end

data/lib/standard/loads_yaml_config.rb

@@ -32,7 +32,8 @@ module Standard
         default_ignores: standard_yaml.key?("default_ignores") ? !!standard_yaml["default_ignores"] : true,
         config_root: yaml_path ? Pathname.new(yaml_path).dirname.to_s : nil,
         todo_file: todo_path,
-        todo_ignore_files: (todo_yaml["ignore"] || []).map { |f| (Hash === f) ? f.keys.first : f }
+        todo_ignore_files: Array(todo_yaml["ignore"]).map { |f| (Hash === f) ? f.keys.first : f },
+        extend_config: Array(standard_yaml["extend_config"])
       }
     end
 

data/lib/standard/lsp/kills_server.rb

@@ -0,0 +1,10 @@
+module Standard
+  module Lsp
+    class KillsServer
+      def call(&blk)
+        at_exit(&blk) unless blk.nil?
+        exit 0
+      end
+    end
+  end
+end

data/lib/standard/lsp/logger.rb

@@ -0,0 +1,19 @@
+module Standard
+  module Lsp
+    class Logger
+      def initialize
+        @puts_onces = []
+      end
+
+      def puts(message)
+        warn("[server] #{message}")
+      end
+
+      def puts_once(message)
+        return if @puts_onces.include?(message)
+        @puts_onces << message
+        puts(message)
+      end
+    end
+  end
+end

data/lib/standard/lsp/routes.rb

@@ -0,0 +1,204 @@
+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,
+            diagnostic_provider: true,
+            execute_command_provider: true,
+            text_document_sync: Proto::Interface::TextDocumentSyncOptions.new(
+              change: Proto::Constant::TextDocumentSyncKind::FULL
+            )
+          )
+        ))
+      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/diagnostic" do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @writer.write(result)
+      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/didChangeWatchedFiles" do |request|
+        if request[:params][:changes].any? { |change| change[:uri].end_with?(".standard.yml") }
+          @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
+        offenses = @standardizer.offenses(uri_to_path(file_uri), text)
+
+        lsp_diagnostics = offenses.map { |o|
+          code = o[:cop_name]
+
+          msg = o[:message].delete_prefix(code)
+          loc = o[:location]
+
+          severity = case o[:severity]
+          when "error", "fatal"
+            SEV::ERROR
+          when "warning"
+            SEV::WARNING
+          when "convention"
+            SEV::INFORMATION
+          when "refactor", "info"
+            SEV::HINT
+          else # the above cases fully cover what RuboCop sends at this time
+            logger.puts "Unknown severity: #{severity.inspect}"
+            SEV::HINT
+          end
+
+          {
+            code: code,
+            message: msg,
+            range: {
+              start: {character: loc[:start_column] - 1, line: loc[:start_line] - 1},
+              end: {character: loc[:last_column] - 1, line: loc[:last_line] - 1}
+            },
+            severity: severity,
+            source: "standard"
+          }
+        }
+
+        {
+          method: "textDocument/publishDiagnostics",
+          params: {
+            uri: file_uri,
+            diagnostics: lsp_diagnostics
+          }
+        }
+      end
+    end
+  end
+end

data/lib/standard/lsp/server.rb

@@ -1,144 +1,36 @@
 require "language_server-protocol"
 require_relative "standardizer"
+require_relative "routes"
+require_relative "logger"
 
 module Standard
-  module LSP
-    class Server
-      Proto = LanguageServer::Protocol
-      SEV = Proto::Constant::DiagnosticSeverity
-
-      def self.start(standardizer)
-        new(standardizer).start
-      end
-
-      attr_accessor :standardizer, :writer, :reader, :logger, :text_cache, :subscribers
-
-      def initialize(standardizer)
-        self.standardizer = standardizer
-        self.writer = Proto::Transport::Io::Writer.new($stdout)
-        self.reader = Proto::Transport::Io::Reader.new($stdin)
-        self.logger = $stderr
-        self.text_cache = {}
-
-        self.subscribers = {
-          "initialize" => ->(request) {
-            init_result = Proto::Interface::InitializeResult.new(
-              capabilities: Proto::Interface::ServerCapabilities.new(
-                document_formatting_provider: true,
-                diagnostic_provider: true,
-                text_document_sync: Proto::Constant::TextDocumentSyncKind::FULL
-              )
-            )
-            writer.write(id: request[:id], result: init_result)
-          },
-
-          "initialized" => ->(request) { logger.puts "standard v#{Standard::VERSION} initialized, pid #{Process.pid}" },
+  module Lsp
+    Proto = LanguageServer::Protocol
+    SEV = Proto::Constant::DiagnosticSeverity
 
-          "shutdown" => ->(request) {
-            logger.puts "asked to shutdown, exiting..."
-            exit
-          },
-
-          "textDocument/didChange" => ->(request) {
-            params = request[:params]
-            result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
-            writer.write(result)
-          },
-
-          "textDocument/didOpen" => ->(request) {
-            td = request[:params][:textDocument]
-            result = diagnostic(td[:uri], td[:text])
-            writer.write(result)
-          },
-
-          "textDocument/didClose" => ->(request) {
-            text_cache.delete(request.dig(:params, :textDocument, :uri))
-          },
-
-          "textDocument/formatting" => ->(request) {
-            uri = request[:params][:textDocument][:uri]
-            writer.write({id: request[:id], result: format_file(uri)})
-          },
-
-          "textDocument/didSave" => ->(request) {}
-        }
+    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, @logger)
+        @routes = Routes.new(@writer, @logger, @standardizer)
       end
 
       def start
-        reader.read do |request|
-          method = request[:method]
-          if (subscriber = subscribers[method])
-            subscriber.call(request)
+        @reader.read do |request|
+          if !request.key?(:method)
+            @routes.handle_method_missing(request)
+          elsif (route = @routes.for(request[:method]))
+            route.call(request)
           else
-            logger.puts "unknown method: #{method}"
+            @routes.handle_unsupported_method(request)
           end
         rescue => e
-          logger.puts "error #{e.class} #{e.message[0..100]}"
-          logger.puts e.backtrace.inspect
+          @logger.puts "Error #{e.class} #{e.message[0..100]}"
+          @logger.puts e.backtrace.inspect
         end
       end
-
-      def format_file(file_uri)
-        text = text_cache[file_uri]
-        new_text = standardizer.format(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
-
-      def diagnostic(file_uri, text)
-        text_cache[file_uri] = text
-        offenses = standardizer.offenses(text)
-
-        lsp_diagnostics = offenses.map { |o|
-          code = o[:cop_name]
-
-          msg = o[:message].delete_prefix(code)
-          loc = o[:location]
-
-          severity = case o[:severity]
-          when "error", "fatal"
-            SEV::ERROR
-          when "warning"
-            SEV::WARNING
-          when "convention"
-            SEV::INFORMATION
-          when "refactor", "info"
-            SEV::HINT
-          else # the above cases fully cover what RuboCop sends at this time
-            logger.puts "unknown severity: #{severity.inspect}"
-            SEV::HINT
-          end
-
-          {
-            code: code,
-            message: msg,
-            range: {
-              start: {character: loc[:start_column] - 1, line: loc[:start_line] - 1},
-              end: {character: loc[:last_column] - 1, line: loc[:last_line] - 1}
-            },
-            severity: severity,
-            source: "standard"
-          }
-        }
-
-        {
-          method: "textDocument/publishDiagnostics",
-          params: {
-            diagnostics: lsp_diagnostics,
-            uri: file_uri
-          }
-        }
-      end
     end
   end
 end

data/lib/standard/lsp/standardizer.rb

@@ -1,49 +1,65 @@
 require_relative "../runners/rubocop"
-require "tempfile"
 
 module Standard
-  module LSP
+  module Lsp
     class Standardizer
-      def initialize(config)
-        @template_options = config
-        @runner = Standard::Runners::Rubocop.new
+      def initialize(config, logger)
+        @config = config
+        @logger = logger
+        @rubocop_runner = Standard::Runners::Rubocop.new
       end
 
-      def format(text)
-        run_standard(text, format: true)
+      # This abuses the --stdin option of rubocop and reads the formatted text
+      # from the options[:stdin] that rubocop mutates. This depends on
+      # parallel: false as well as the fact that rubocop doesn't otherwise dup
+      # or reassign that options object. Risky business!
+      #
+      # Reassigning options[:stdin] is done here:
+      #   https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/team.rb#L131
+      # Printing options[:stdin]
+      #   https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cli/command/execute_runner.rb#L95
+      # Setting `parallel: true` would break this here:
+      #   https://github.com/rubocop/rubocop/blob/master/lib/rubocop/runner.rb#L72
+      def format(path, text)
+        ad_hoc_config = fork_config(path, text, format: true)
+        capture_rubocop_stdout(ad_hoc_config)
+        ad_hoc_config.rubocop_options[:stdin]
       end
 
-      def offenses(text)
-        results = run_standard(text, format: false)
-        JSON.parse(results, symbolize_names: true).dig(:files, 0, :offenses)
+      def offenses(path, text)
+        results = JSON.parse(
+          capture_rubocop_stdout(fork_config(path, text, format: false)),
+          symbolize_names: true
+        )
+        if results[:files].empty?
+          @logger.puts_once "Ignoring file, per configuration: #{path}"
+          []
+        else
+          results.dig(:files, 0, :offenses)
+        end
       end
 
       private
 
-      BASENAME = ["source", ".rb"].freeze
-      def run_standard(text, format:)
-        Tempfile.open(BASENAME) do |temp|
-          temp.write(text)
-          temp.flush
-          stdout = capture_rubocop_stdout(make_config(temp.path, format))
-          format ? File.read(temp.path) : stdout
-        end
-      end
-
-      def make_config(file, format)
-        # Can't make frozen versions of this hash because RuboCop mutates it
-        o = if format
-          {autocorrect: true, formatters: [["Standard::Formatter", nil]], parallel: true, todo_file: nil, todo_ignore_files: [], safe_autocorrect: true}
+      BASE_OPTIONS = {
+        force_exclusion: true,
+        parallel: false,
+        todo_file: nil,
+        todo_ignore_files: []
+      }
+      def fork_config(path, text, format:)
+        options = if format
+          {stdin: text, autocorrect: true, formatters: [], safe_autocorrect: true}
         else
-          {autocorrect: false, formatters: [["json"]], parallel: true, todo_file: nil, todo_ignore_files: [], format: "json"}
+          {stdin: text, autocorrect: false, formatters: [["json"]], format: "json"}
         end
-        Standard::Config.new(@template_options.runner, [file], o, @template_options.rubocop_config_store)
+        Standard::Config.new(@config.runner, [path], BASE_OPTIONS.merge(options), @config.rubocop_config_store)
       end
 
       def capture_rubocop_stdout(config)
         redir = StringIO.new
         $stdout = redir
-        @runner.call(config)
+        @rubocop_runner.call(config)
         redir.string
       ensure
         $stdout = STDOUT

data/lib/standard/merges_settings.rb

@@ -20,7 +20,7 @@ module Standard
 
     def separate_argv(argv)
       argv.partition do |flag|
-        ["--generate-todo", "--fix", "--no-fix", "--version", "-v", "--help", "-h", "--lsp"].include?(flag)
+        ["--generate-todo", "--fix", "--no-fix", "--version", "-v", "--verbose-version", "-V", "--help", "-h", "--lsp"].include?(flag)
       end
     end
 
@@ -39,6 +39,8 @@ 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?

data/lib/standard/rubocop/ext.rb

@@ -13,4 +13,13 @@ module RuboCop
         .gsub(" ", '\s*')
     )
   end
+
+  class CommentConfig
+    alias_method :old_initialize, :initialize
+
+    def initialize(processed_source)
+      old_initialize(processed_source)
+      @no_directives &&= !processed_source.raw_source.include?("standard")
+    end
+  end
 end

data/lib/standard/runners/help.rb

@@ -15,6 +15,7 @@ module Standard
             --generate-todo   Create a .standard_todo.yml that lists all the files that contain errors
             --lsp             Start a LSP server listening on STDIN
             -v, --version     Print the version of Standard
+            -V, --verbose-version   Print the version of Standard and its dependencies.
             -h, --help        Print this message
             FILE              Files to lint [default: ./]
 

data/lib/standard/runners/lsp.rb

@@ -4,8 +4,7 @@ module Standard
   module Runners
     class Lsp
       def call(config)
-        standardizer = Standard::LSP::Standardizer.new(config)
-        Standard::LSP::Server.start(standardizer)
+        Standard::Lsp::Server.new(config).start
       end
     end
   end

data/lib/standard/runners/verbose_version.rb

@@ -0,0 +1,14 @@
+require_relative "rubocop"
+
+module Standard
+  module Runners
+    class VerboseVersion
+      def call(config)
+        puts <<-MSG.gsub(/^ {10}/, "")
+          Standard version: #{Standard::VERSION}
+          RuboCop version:  #{RuboCop::Version.version(debug: true)}
+        MSG
+      end
+    end
+  end
+end

data/lib/standard/version.rb

@@ -1,3 +1,3 @@
 module Standard
-  VERSION = Gem::Version.new("1.21.0")
+  VERSION = Gem::Version.new("1.24.3")
 end

data/standard.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rubocop", "1.42.0"
+  spec.add_dependency "rubocop", "1.44.1"
   spec.add_dependency "rubocop-performance", "1.15.2"
 
   # not semver: first three are lsp protocol version, last is patch

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard
 version: !ruby/object:Gem::Version
-  version: 1.21.0
+  version: 1.24.3
 platform: ruby
 authors:
 - Justin Searls
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-03 00:00:00.000000000 Z
+date: 2023-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.42.0
+        version: 1.44.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.42.0
+        version: 1.44.1
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.17.0.2
-description: 
+description:
 email:
 - searls@gmail.com
 executables:
@@ -95,12 +95,16 @@ files:
 - lib/standard/creates_config_store.rb
 - lib/standard/creates_config_store/assigns_rubocop_yaml.rb
 - lib/standard/creates_config_store/configures_ignored_paths.rb
+- lib/standard/creates_config_store/merges_user_config_extensions.rb
 - lib/standard/creates_config_store/sets_target_ruby_version.rb
 - lib/standard/detects_fixability.rb
 - lib/standard/file_finder.rb
 - lib/standard/formatter.rb
 - lib/standard/loads_runner.rb
 - lib/standard/loads_yaml_config.rb
+- lib/standard/lsp/kills_server.rb
+- lib/standard/lsp/logger.rb
+- lib/standard/lsp/routes.rb
 - lib/standard/lsp/server.rb
 - lib/standard/lsp/standardizer.rb
 - lib/standard/merges_settings.rb
@@ -112,13 +116,14 @@ files:
 - lib/standard/runners/help.rb
 - lib/standard/runners/lsp.rb
 - lib/standard/runners/rubocop.rb
+- lib/standard/runners/verbose_version.rb
 - lib/standard/runners/version.rb
 - lib/standard/version.rb
 - standard.gemspec
 homepage: https://github.com/testdouble/standard
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -133,8 +138,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Ruby Style Guide, with linter & automatic code fixer
 test_files: []